dsh-sansheng-liubu/index.js

463 lines
26 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import fs from 'node:fs'
import os from 'node:os'
import path from 'node:path'
import { createWorkbenchHost, resolveStorePath } from './workbench/host/index.mjs'
const PRESET_ID = 'sansheng-liubu'
export const POLICY_VERSION = '0.5.0'
/**
* 默认不强制任何 provider/model:宿主未必注册了这些适配器,强行指定会让整轮请求
* 以 NO_ADAPTER 失败(例如 "no adapter registered for provider xiaomi")。
* 角色模型改由面板里的「联动模型」按当前宿主目录选择,或在 preset 配置里显式给 routes。
*/
export const DEFAULT_ROUTES = Object.freeze({})
/** 三省六部:丞相 1 + 三省 3 + 六部 6 = 10 席;六部为吏、户、礼、兵、刑、工。 */
export const COURT_ROLES = Object.freeze([
'lead', 'zhongshu', 'menxia', 'shangshu',
'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu',
])
const KNOWN_ROLES = new Set(['zhongshu', 'menxia', 'shangshu', 'libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
const READ_ONLY_ROLES = new Set(['lead', 'zhongshu', 'menxia', 'shangshu', 'minister'])
const EXECUTION_ROLES = new Set(['libu', 'hubu', 'lipu', 'bingbu', 'xingbu', 'gongbu'])
const IMAGE_TOOLS = new Set(['generate_image', 'generate_images', 'edit_image'])
const FORBIDDEN_IMAGE_TOOLS = new Set(['image_generate', 'codex_image_generate'])
export const READ_ONLY_TOOLSET = Object.freeze(['read', 'grep', 'glob'])
export const EXECUTION_TOOLSET = Object.freeze(['read', 'write', 'edit', 'bash', 'pwsh', 'grep', 'glob'])
const MANAGEMENT_TOOL_PREFIXES = Object.freeze(['task_board_', 'automation_'])
const OTHER_MANAGEMENT_TOOLS = new Set(['create_skill', 'plugin_manager'])
const HUMAN_SIGNATURE_TOOLS = new Set([
'create_skill', 'plugin_manager', 'remote_ssh_delete', 'automation_delete',
])
const MUTATING_TOOLS = new Set([
'write', 'edit', 'pwsh', 'bash',
'remote_ssh_write', 'remote_ssh_mkdir', 'remote_ssh_exec',
'ws_mcp_call', ...IMAGE_TOOLS,
])
/**
* 六部各自可改什么,按职责划线,不互相借用:
* - 吏部:技能与角色文件(.md/.json/.yml 等),不开命令行,避免改代码或环境。
* - 户部:数据文件(xlsx/csv/parquet 等);重算与渲染交 Office/Univer 工具,故不开命令行。
* - 礼部:文档、汇报与截图等材料产出。
* - 兵部:跑命令、定位问题,另含远程与 MCP 通道。
* - 刑部:测试与专项验证,只跑不部署;远程命令会绕过风险分级,因此不给。
* - 工部:代码实现,含 Image-gen 生图。
*/
const ROLE_ALLOWED_MUTATIONS = Object.freeze({
libu: new Set(['write', 'edit']),
hubu: new Set(['write', 'edit']),
lipu: new Set(['write', 'edit', 'pwsh', 'bash']),
bingbu: new Set([
'write', 'edit', 'pwsh', 'bash',
'remote_ssh_write', 'remote_ssh_mkdir', 'remote_ssh_exec', 'ws_mcp_call',
]),
xingbu: new Set(['write', 'edit', 'pwsh', 'bash']),
gongbu: new Set(['write', 'edit', 'pwsh', 'bash', ...IMAGE_TOOLS]),
})
const TOOL_GOVERNANCE = `## 工具开放审核则例
一、凡部门需用工具,须奏明用途、范围、期限,经门下省审核,准奏后由兵部发放,限期使用,到期收回销账。
二、只读之具,门下可专决;改易文件者,须注明写入范围;涉费、删除、全局配置者,须人工签字。
三、兵部掌武库:工具装配、发放、回收、登记,只发不批;管理型工具(task_board_*、automation_*)与付费开关归丞相执掌,用时留痕;执行部门常备文件读写、命令行、测试之具。
四、门下验收查账,越界者下次从严;所授之具不得转借。`
const LEAD_PROMPT = `# 三省六部模式:丞相
你是本会话的丞相,也是 Agent Team Lead。你直接面向用户,负责定策、组队、监督制度执行与最终回奏;不要亲自修改文件。
## 固定组织(三省六部十席)
- zhongshu(中书省):调查现状、澄清需求、起草方案,只读。
- menxia(门下省):独立审议、准奏或封驳,并在执行后验收,只读。
- shangshu(尚书省):把批准方案转成任务依赖、按吏户礼兵刑工六部分工,只读。
- libu(吏部):Agent 与技能维护,只动技能、角色与配置文档。
- hubu(户部):数据、表格与计算,负责真实数据与可复算的结论。
- lipu(礼部):文档、汇报与可视化产出。
- bingbu(兵部):环境运行、调试与部署,掌工具装配、发放、回收、登记与销账,只发不批。
- xingbu(刑部):按风险做专项测试与独立验证,只跑不部署。
- gongbu(工部):编码与工程实现,负责落盘改动、构建与安装脚本。
## 强制流程
1. 对实质性任务,先创建 zhongshu、menxia、shangshu;成员名必须完全使用上述英文 id。
2. 在共享任务板建立“中书拟案”→“门下审议”→“尚书派工”→执行任务→“尚书合成”→“门下审核”的依赖链。
3. 中书提交可执行方案和验收标准;门下只能输出准奏或封驳,封驳必须给出阻塞问题;审议默认一轮。
4. 门下准奏前不得进入执行。准奏后先向用户回奏「方案 + 审议结论 + 拟派分工」,取得用户明确确认(“准奏”“开始”“可以”等)后,才让尚书派工;六部成员(libu、hubu、lipu、bingbu、xingbu、gongbu)只有 Lead 能创建,且只召集本任务真正用到的部门,不得为凑齐六部而拆分。
5. 每个执行部门必须先领取自己的 in_progress 任务;写入范围写进 writeScopes,依赖必须全部完成;执行完先自检再上缴。
6. 六部完成后由尚书合成一份整体结果,再交门下按验收标准审核;审核失败时,执行部门修复一次,再次失败则如实报告并请求用户决定。
7. 回复用户前必须等待所有必需成员完成,最终使用“丞相回奏”格式汇总方案、审议、执行、验证和风险;若只有部分成果通过,必须附「部分 → 主责部门」清单,写清哪一部门未交付及原因。
${TOOL_GOVERNANCE}
禁止调用 GPT 模型或 codex_image_generate。`
const ROLE_PROMPTS = Object.freeze({
zhongshu: `# 中书省职责
你负责调查、规划和任务拆解。只读,不得修改文件或运行有副作用的命令。先读取实际项目与约束,再产出:目标、非目标、任务 DAG、writeScopes、风险和验收标准。将结果发送给丞相与门下省。收到封驳后只针对阻塞问题修订。\n\n${TOOL_GOVERNANCE}`,
menxia: `# 门下省职责
你是独立审核者,只读,不得替中书改方案或替执行部门实施。审议必须给出 verdict=approve|reject、blockingIssues、risks、acceptanceCriteria。存在阻塞问题必须封驳;准奏时完成“门下审议”任务。执行后查验工具发放、使用、回收与销账记录,并依据验收标准检查证据;验收对象是尚书合成的整体结果,六部须先自检再上缴。\n\n${TOOL_GOVERNANCE}`,
shangshu: `# 尚书省职责
你只负责调度设计,不直接写文件,也不能创建 teammate。把门下批准的方案转成共享任务、依赖、负责人建议和互不重叠的 writeScopes;按吏户礼兵刑工的职责分工,通知丞相创建本任务真正需要的六部成员。跟踪状态、汇总异常,并在所需部门完成或部分完成后合成一份整体结果(含未完成项与主责部门)交门下审核。只调用必要的部门:一个部门能完成的不要拆给多个部门,同类小任务合并派工。\n\n${TOOL_GOVERNANCE}`,
libu: `# 吏部职责
你负责 Agent 与技能维护:技能设计与评估、角色配置与成员编制文档。可用的写入工具限于此范围,不写业务代码、不跑命令行、不改数据。仅当新增或实质改进技能时才安排评测,普通配置修改不启动多代理基准测试;不擅自更换模型或扩大权限。实施前领取自己的任务并确认 blocker 已完成,仅改声明的 writeScopes,完成后提交改动清单与自检结果。\n\n常备工具:write、edit、read、grep、glob。\n\n${TOOL_GOVERNANCE}`,
hubu: `# 户部职责
你负责数据与计算:表格、数据文件、统计与可复算的结论。可用的写入工具只用于数据文件;读取、重算与渲染交宿主提供的 Office / Univer 工具,不跑命令行。依据实际数据选择统计方法,不把表格操作等同于统计验证,不补造数据;无法核实时如实标注未核实。实施前领取自己的任务并确认 blocker 已完成,完成后提交数据来源、口径与复算方式。\n\n常备工具:write、edit、read、grep、glob。\n\n${TOOL_GOVERNANCE}`,
lipu: `# 礼部职责
你负责文档、汇报、文案润色与可视化产出,包括 README、变更记录与演示材料。实施前领取自己的任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。完成后向丞相和门下提交成稿与自检结果。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
bingbu: `# 兵部职责
你负责环境运行、调试与部署,并掌武库:工具装配、发放、回收、登记、销账,只发不批。实施前读取任务、领取任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。先复现再定位,运行适用命令与测试,报告复现步骤、根因、修复文件、测试结果、工具台账和剩余风险。部署发布须在授权范围内。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
xingbu: `# 刑部职责
你负责按风险开展的专项测试与独立验证,不承担门下成品审议,也不部署。采用复现定位与有效测试设计:给出问题位置、证据与影响,不越权修改他部成果;修复由主责部门完成。不是每项任务都必经你手,只在风险需要时受派。实施前领取自己的任务并确认 blocker 已完成;仅修改声明的 writeScopes(测试代码与报告)。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
gongbu: `# 工部职责
你负责代码实现、构建、安装脚本与文件落地。实施前领取自己的任务并确认所有 blocker 已完成;仅修改声明的 writeScopes。先读后改,改完运行适用的构建或测试命令,报告修改文件、执行结果和剩余风险。\n\n常备工具:${EXECUTION_TOOLSET.join('、')}。\n\n${TOOL_GOVERNANCE}`,
minister: `# 执行成员职责
你是三省六部团队中的临时成员。服从丞相调度,先领取任务并尊重依赖与 writeScopes;不要绕过门下审核。\n\n${TOOL_GOVERNANCE}`,
})
export function roleFromMembership(membership) {
// A normal newly-created preset session has no Agent Team membership yet.
// Treat that primary/default agent as the Chancellor so users converse with
// the Lead immediately, before the Chancellor creates the remaining court.
if (!membership) return 'lead'
if (membership.role === 'lead') return 'lead'
const name = String(membership.name || '').trim().toLowerCase()
return KNOWN_ROLES.has(name) ? name : 'minister'
}
export function routeForRole(role, routes = DEFAULT_ROUTES) {
if (!routes) return undefined
return routes[role] ?? routes.minister
}
export function toolsetForRole(role) {
return EXECUTION_ROLES.has(role) ? [...EXECUTION_TOOLSET] : [...READ_ONLY_TOOLSET]
}
function hasExecutableAssignment(role, tasks) {
const byId = new Map(tasks.map(task => [task.id, task]))
return tasks.some(task => task.status === 'in_progress' && task.ownerName === role &&
(task.blockedBy ?? []).every(id => byId.get(id)?.status === 'completed'))
}
function managementApproval(role, toolName, tasks, now = Date.now()) {
return tasks.find(task => {
const approval = task?.approval
if (task.status !== 'in_progress' || task.ownerName !== role || !approval) return false
if (approval.reviewer !== 'menxia' || approval.verdict !== 'approve') return false
if (!approval.purpose || !approval.scope || !approval.expiresAt) return false
if (Date.parse(approval.expiresAt) <= now) return false
return Array.isArray(approval.tools) && approval.tools.some(entry => entry === toolName ||
(entry.endsWith('*') && toolName.startsWith(entry.slice(0, -1))))
})
}
function isManagementTool(toolName) {
return OTHER_MANAGEMENT_TOOLS.has(toolName) || MANAGEMENT_TOOL_PREFIXES.some(prefix => toolName.startsWith(prefix))
}
export function evaluateToolPolicy(role, toolName, tasks = [], options = {}) {
const audit = typeof options.audit === 'function' ? options.audit : () => {}
if (FORBIDDEN_IMAGE_TOOLS.has(toolName)) return `上朝模式只允许使用 Image-gen 工具,不得调用 ${toolName}。`
const destructiveBoardAction = toolName === 'task_board_manage' && options.args?.action === 'delete'
if ((HUMAN_SIGNATURE_TOOLS.has(toolName) || destructiveBoardAction) && options.humanSigned !== true) {
return `${toolName} 涉及删除或全局配置,须先取得人工签字。`
}
if (isManagementTool(toolName)) {
if (role === 'lead') {
audit({ action: 'management-tool', role, toolName, decision: 'allow', authority: 'chancellor' })
return undefined
}
const approval = managementApproval(role, toolName, tasks, options.now)
if (!approval) return `${role} 调用管理型工具 ${toolName} 前须提交用途、范围、期限,并取得门下省准奏记录。`
audit({ action: 'management-tool', role, toolName, decision: 'allow', approvalId: approval.id })
return undefined
}
if (!MUTATING_TOOLS.has(toolName)) {
// 走到这里的不是禁用工具,也过了签字与管理工具两关。剩下两类:
// 登记在册的只读工具、刚核验过人工签字的签字类工具,放行;
// 其余从没登记过的工具一律先拦——「没在名单里」不等于只读安全,
// 问清它只读还是会改动、登记进对应分类后才放行。
if (READ_ONLY_TOOLSET.includes(toolName) || HUMAN_SIGNATURE_TOOLS.has(toolName)) return undefined
return `${toolName} 尚未登记分类,未知工具默认拦截:请先确认它只读还是会改动,只读的登记进只读工具集、会改动的登记进写入分类,再放行。`
}
if (READ_ONLY_ROLES.has(role)) return `${role} 是只读规划、审核或调度角色,不得调用写入型工具 ${toolName}。`
if (!EXECUTION_ROLES.has(role)) return `${role} 不是获准的执行部门,不能调用 ${toolName}。`
if (!ROLE_ALLOWED_MUTATIONS[role]?.has(toolName)) return `${toolName} 不属于 ${role} 的职责范围。`
if (!hasExecutableAssignment(role, tasks)) return `${role} 尚未准奏:请先领取一个 in_progress 且所有 blocker 已完成的共享任务。`
return undefined
}
function rolePrompt(role) { return role === 'lead' ? LEAD_PROMPT : ROLE_PROMPTS[role] ?? ROLE_PROMPTS.minister }
function normalizeRoutes(routes = {}) {
const merged = { ...DEFAULT_ROUTES }
for (const [role, route] of Object.entries(routes)) {
if (!route || typeof route !== 'object') continue
if (typeof route.provider !== 'string' || typeof route.model !== 'string') continue
merged[role] = { provider: route.provider, model: route.model,
...(typeof route.reasoningEffort === 'string' ? { reasoningEffort: route.reasoningEffort } : {}) }
}
return merged
}
/**
* 面板上的「部门模型」走这条指令:宿主的 session.selectModel 会拒绝子会话
* (`session.header.origin === "subagent"` → session/agent-busy),所以部门模型
* 只能由本插件在 agent/request 时改,面板则用 /dept-model 把选择下发过来。
*/
export const DEPT_MODEL_COMMAND = 'dept-model'
export const DEPT_MODEL_USAGE = '<部门> <provider> <model> [推理等级] | list | clear [部门]'
export function routesFilePath(env = process.env) {
const home = typeof env.DSH_HOME === 'string' && env.DSH_HOME.trim() ? env.DSH_HOME.trim() : path.join(os.homedir(), '.dsh')
return path.join(home, 'sansheng-liubu', 'routes.json')
}
export function readStoredRoutes(file) {
try {
const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
return normalizeRoutes(parsed && typeof parsed === 'object' ? parsed : {})
} catch (error) { return {} }
}
export function writeStoredRoutes(file, routes) {
try {
fs.mkdirSync(path.dirname(file), { recursive: true })
fs.writeFileSync(file, JSON.stringify(routes, null, 2) + '\n', 'utf8')
return true
} catch (error) { return false }
}
export function parseDeptModelCommand(rawInput) {
const tokens = String(rawInput === undefined || rawInput === null ? '' : rawInput).trim().split(/\s+/).filter(Boolean)
if (tokens.length === 0 || tokens[0].toLowerCase() === 'list') return { action: 'list' }
const head = tokens[0].toLowerCase()
if (head === 'clear' || head === 'reset') {
const role = (tokens[1] || '').toLowerCase()
if (role && !COURT_ROLES.includes(role)) return { action: 'error', reason: `未知部门:${tokens[1]}` }
return { action: 'clear', role: role || undefined }
}
if (!COURT_ROLES.includes(head)) return { action: 'error', reason: `未知部门:${tokens[0]}(可用:${COURT_ROLES.join('、')})` }
if (tokens.length < 3) return { action: 'error', reason: `用法:/${DEPT_MODEL_COMMAND} ${DEPT_MODEL_USAGE}` }
const reasoningEffort = tokens[3]
return {
action: 'set',
role: head,
route: { provider: tokens[1], model: tokens[2], ...(reasoningEffort ? { reasoningEffort } : {}) },
}
}
export function describeDeptRoutes(routes = {}) {
const entries = Object.entries(routes).filter(([, route]) => route && route.provider && route.model)
if (entries.length === 0) return `十席目前都跟随宿主默认模型;用 /${DEPT_MODEL_COMMAND} ${DEPT_MODEL_USAGE} 逐个固定。`
return '部门固定模型:' + entries
.map(([role, route]) => `${role}=${route.provider}/${route.model}${route.reasoningEffort ? '·' + route.reasoningEffort : ''}`)
.join(';')
}
function registerDeptModelCommand(ctx, handler) {
if (!ctx.commands || typeof ctx.commands.register !== 'function') return () => {}
try {
const dispose = ctx.effect(function* () {
yield ctx.commands.register({
name: DEPT_MODEL_COMMAND,
description: '固定某个部门的模型(面板「模型设置」用)',
input: { hint: DEPT_MODEL_USAGE },
handler: invocation => handler(invocation && invocation.rawInput),
})
}, `sansheng-liubu: /${DEPT_MODEL_COMMAND}`)
return typeof dispose === 'function' ? dispose : () => {}
} catch (error) {
ctx.logger?.warn?.(`[sansheng-liubu] 注册 /${DEPT_MODEL_COMMAND} 失败:${error && error.message ? error.message : error}`)
return () => {}
}
}
const INSTALLATIONS = globalThis[Symbol.for('dsh.sansheng-liubu.installations')] ??=
new WeakMap()
/**
* 工作台是“整台机器一份”,不是“每个 agent 一份”:同一份账本只能有一个写者。
* 但本插件的 apply 可能被多次调用(每个组合了「上朝」预设的 agent 各一次),
* 所以按账本路径引用计数:最后一个卸载时才真的 dispose,中途不重复建 store。
*/
const WORKBENCH = globalThis[Symbol.for('dsh.sansheng-liubu.workbench')] ??= new Map()
/**
* 只有真的跑在宿主里才建工作台:单测用 mock ctx 调 apply() 时不该往
* %DSH_HOME% 写账本、也不该起对账计时器。cordis 的 Context 一定有 get()。
*/
function hostSurfaceAvailable(ctx) {
if (!ctx) return false
if (typeof ctx.get === 'function') return true
return Boolean(ctx.webServer || ctx.sessionController || ctx.remote)
}
function acquireWorkbench(ctx, presetId, log) {
if (!hostSurfaceAvailable(ctx)) return null
let file = null
try {
file = resolveStorePath(process.env)
} catch {
// 拿不到路径就退回内存账本,不能因为一个路径算不出来就让政策插件加载失败。
file = null
}
const key = file ?? '(memory)'
const existing = WORKBENCH.get(key)
if (existing) {
existing.refs += 1
return existing
}
const entry = { refs: 1, host: null, key }
try {
// 挂在 root 上:工作台属于整个应用,不该随某个 agent 的销毁一起消失。
entry.host = createWorkbenchHost(ctx?.root ?? ctx, { presetId })
for (const warning of entry.host.warnings ?? []) log?.(warning)
log?.(`账本 ${entry.host.file};接口${entry.host.registered ? '已注册' : '未注册'};`
+ `会话层${entry.host.hasSessions ? '可用' : '不可用(派发只落账)'}`)
} catch (error) {
log?.(`工作台启动失败:${error?.message ?? error}`)
entry.host = null
}
WORKBENCH.set(key, entry)
return entry
}
function releaseWorkbench(entry) {
if (!entry || entry !== WORKBENCH.get(entry.key)) return
entry.refs -= 1
if (entry.refs > 0) return
WORKBENCH.delete(entry.key)
try {
entry.host?.dispose?.()
} catch {
// 卸载失败不影响插件卸载;下次启动仍会从同一个账本继续。
}
}
export const name = 'sansheng-liubu-mode'
export const inject = ['agents', 'agentTeams', 'agentPresets', 'systemPrompt', 'tools', 'commands']
export function apply(ctx, config = {}) {
const presetId = typeof config.presetId === 'string' ? config.presetId : PRESET_ID
const routeFile = routesFilePath()
const routes = normalizeRoutes({ ...readStoredRoutes(routeFile), ...(config.routes || {}) })
const owned = new Map()
const audit = entry => ctx.logger?.info?.(`[sansheng-liubu:audit] ${JSON.stringify({ at: new Date().toISOString(), ...entry })}`)
// 工作台:账本 + 部门会话 + HTTP 接口。整体失败只记日志,不能让政策插件加载不了——
// 「上朝」的 prompt/工具策略是刚需,工作台是增量能力。
const logWorkbench = message => {
try {
ctx.logger?.info?.(`[sansheng-liubu:workbench] ${message}`)
} catch {
/* 日志失败不影响业务 */
}
}
const workbench = acquireWorkbench(ctx, presetId, logWorkbench)
const persist = () => {
if (writeStoredRoutes(routeFile, routes)) return
ctx.logger?.warn?.(`[sansheng-liubu] 路由表写入失败:${routeFile}`)
}
const runDeptModel = rawInput => {
const parsed = parseDeptModelCommand(rawInput)
if (parsed.action === 'error') return { kind: 'error', text: parsed.reason }
if (parsed.action === 'list') return { kind: 'success', text: describeDeptRoutes(routes) }
if (parsed.action === 'clear') {
if (parsed.role) delete routes[parsed.role]
else for (const role of Object.keys(routes)) delete routes[role]
persist()
return {
kind: 'success',
text: parsed.role ? `${parsed.role} 已恢复跟随宿主默认模型。` : '十席都已恢复跟随宿主默认模型。',
}
}
routes[parsed.role] = parsed.route
persist()
const effort = parsed.route.reasoningEffort ? `(推理等级 ${parsed.route.reasoningEffort})` : ''
return {
kind: 'success',
text: `${parsed.role} 已固定为 ${parsed.route.provider}/${parsed.route.model}${effort},该部门下一轮开工即生效。`,
}
}
const disposeCommand = registerDeptModelCommand(ctx, runDeptModel)
const uninstall = agent => {
const release = owned.get(agent)
if (!release) return
owned.delete(agent)
release()
}
const install = agent => {
if (owned.has(agent)) return
if (ctx.agentPresets.composedPreset(agent.ctx) !== presetId) return
const membership = ctx.agentTeams.tryMembership(agent)
const role = roleFromMembership(membership)
if (!role) return
const existing = INSTALLATIONS.get(agent)
if (existing) {
existing.refs += 1
owned.set(agent, () => {
existing.refs -= 1
if (existing.refs === 0) { existing.dispose(); INSTALLATIONS.delete(agent) }
})
return
}
const scoped = agent.ctx
const dispose = scoped.effect(() => {
const disposers = []
try {
disposers.push(scoped.systemPrompt.section({
name: 'sansheng-liubu:role',
order: scoped.systemPrompt.getSectionOrder('TEAM_POLICY') + 1,
text: rolePrompt(role),
}))
disposers.push(scoped.on('agent/request', async (_payload, next) => {
const resolved = await next()
const route = routeForRole(role, routes)
if (!route) return resolved
const { reasoningEffort: _oldEffort, ...base } = resolved
return { ...base, provider: route.provider, model: route.model,
...(route.reasoningEffort ? { reasoningEffort: route.reasoningEffort } : {}) }
}, { prepend: true }))
disposers.push(scoped.tools.guard(execution => {
const tasks = ctx.agentTeams.listTasks(agent)
return evaluateToolPolicy(role, execution.name, tasks, {
audit,
humanSigned: execution?.approval?.humanSigned === true || execution?.humanSigned === true,
args: execution?.args,
})
}))
} catch (error) {
for (const cleanup of disposers.reverse()) cleanup()
throw error
}
return () => { for (const cleanup of disposers.reverse()) cleanup() }
})
const shared = { refs: 1, dispose }
INSTALLATIONS.set(agent, shared)
owned.set(agent, () => {
shared.refs -= 1
if (shared.refs === 0) { shared.dispose(); INSTALLATIONS.delete(agent) }
})
}
for (const agent of ctx.agents.list()) install(agent)
const disposeCreated = ctx.on('agent/created', ({ agent }) => install(agent))
const disposeDisposed = ctx.on('agent/disposed', ({ agent }) => uninstall(agent))
return () => {
disposeCommand()
disposeCreated()
disposeDisposed()
for (const agent of [...owned.keys()]) uninstall(agent)
releaseWorkbench(workbench)
}
}