dsh-my-go 0.2.2 → 0.3.0

package/docs/FORK-GUIDE.md

@@ -0,0 +1,159 @@
+# dsh-my-go（Tisitan fork）架构导览
+
+> 面向使用者的「逻辑图 + 文件目录 + 机制映射」说明：系统改成什么样了、
+> 每个功能由哪个文件通过什么原理实现。配套修复台账见 [CHANGELOG.md](../CHANGELOG.md)。
+
+## 一、全景逻辑图
+
+```
+                        ┌──────────────────────── 同一 Node 进程（同一棵 cordis fiber 树）────────────────────────┐
+                        │                                                                                        │
+ 用户 ──► DSH WebUI ──► │  【client 半】dist/client.js（React 插件）                                            │
+ （浏览器）             │   ├─ 🧭 侧栏按钮 ──► shell.overlay 树状图面板（current/queue/help/history）            │
+                        │   ├─ 设置页「MyGO 编排」（8 工种 × provider/model/effort/dsv4p0813）                   │
+                        │   └─ 600ms 轮询 ──┐                                                                   │
+                        │                   ▼ RPC call('/dsh-my-go', endpoint)                                  │
+                        │  【host 半】lib/index.js（profile bundle，global 层注册）                              │
+                        │   ├─ connection.rpc.handle('/dsh-my-go')                                             │
+                        │   │    ├─ snapshot ──► 优先读 Symbol.for('dsh-my-go.snapshot') 全局桥 ──────┐         │
+                        │   │    │                  （桥不在 → 回落自身状态机，非 MyGO 会话用）        │         │
+                        │   │    ├─ loadSettings / saveSettings ──► settings 命名空间 'dsh-my-go'    │         │
+                        │   │    └─ listModels ──► llm.listProviders/listModels                      │         │
+                        │   ├─ ensurePresetInstalled：按版本标记同步 preset/ 到 ~/.dsh/.agent-presets/│         │
+                        │   └─ fallback 编排全家桶（工具+状态机，非 MyGO 会话生效）                    │         │
+                        │                                                                          │ 实时读    │
+                        │  【agent 半】preset/tools/broker.mjs（MyGO preset 装配时加载，preset 层注册）◄┘（零副本）│
+                        │   ├─ Orchestration 状态机（编排真源）                                      │         │
+                        │   │    currentMap(单槽) / queue(FIFO) / helpRequests / history(≤200)      │         │
+                        │   │        ▲ 每次迁移 bump() ──► 发布 latestSnapshot 到 Symbol.for 全局桥 ──┘         │
+                        │   ├─ 6 工具：go_work / continue / need_help / forward /                                │
+                        │   │   orchestration_status / list_subagents（preset 层覆盖 global 同名）             │
+                        │   ├─ systemPrompt 注入：Sisyphus persona + 编排规则（主会话）/ 工种 persona（子代理）  │
+                        │   ├─ agent/request waterfall：按工种绑定 provider/model/reasoningEffort              │
+                        │   ├─ agent/created：拓扑闸（子代理禁派生）+ skill 隐藏（主会话）                       │
+                        │   └─ subagent/end：结论落账 + 队列推进；agent|session/disposed：状态回收             │
+                        │                   │                                                                    │
+                        │                   ▼ ctx.subagents.startContinuable / followup / reportFrom             │
+                        │  【DSH 内核】subagents 服务 ──► 7 种 continuable 子代理会话（独立 Session，可续接）     │
+                        └────────────────────────────────────────────────────────────────────────────────────────┘
+
+ 工具可见性规则（dsh-scope 合并语义）：global 层（lib 注册）+ preset 层（broker 注册），
+ 同名时「最近的 scope 胜出」→ MyGO 会话用 broker 的工具；其他会话用 lib 的工具。互不串台。
+```
+
+## 二、文件目录（fork 现状）
+
+```
+dsh-my-go/
+├── package.json              # 包声明；版本 0.2.3-tisitan.4；test = 冒烟 + 单测
+├── cordis.patch.yml          # bundle patch：dsh plugin add 后自动把 lib 挂进 profile（global 层）
+├── CHANGELOG.md              # fork 修复台账（相对上游的全部差异）
+├── README.md                 # 项目说明（含 fork 标识段）
+│
+├── lib/
+│   └── index.js              # 【host 半】settings 命名空间 + RPC 桥 + preset 同步器
+│                             #   + global 层 fallback 编排（工具/状态机/模型绑定）
+│
+├── preset/                   # agent preset「MyGO!!!!! 模式」（被同步到 ~/.dsh/.agent-presets/）
+│   ├── preset.yml            #   preset 元信息（名称/排序）
+│   ├── agent.cordis.yml      #   agent 平面组合：DSH 官方工具行 + 本地 broker 行 + tool-mask 行
+│   ├── tool-mask.mjs         #   工具屏蔽（nova 配方同步）：藏 Rei 记忆工具 + OpenCode 桥 ×7
+│   └── tools/
+│       └── broker.mjs        #   【agent 半 · 编排真源】状态机 + 6 工具 + prompt 注入
+│                             #     + 模型绑定 + 拓扑闸 + 快照桥发布（★ 大部分修复在这里）
+│
+├── prompts/                  # 8 个工种 persona（broker.mjs 运行时读取并注入）
+│   ├── sisyphus.md           #   总调度+质检官（persona 段进 deployment:persona，
+│   │                         #     「## 编排规则」之后进 dsh-my-go:orchestration section）
+│   ├── hermes.md             #   快速执行（指令明确的体力活）
+│   ├── explore.md            #   快速检索（只读）
+│   ├── librarian.md          #   文档查询
+│   ├── looker.md             #   多模态识别
+│   ├── hephaestus.md         #   代码编写
+│   ├── prometheus.md         #   需求规划（流程开始一次）
+│   └── oracle.md             #   疑难/终验兜底
+│
+├── src/
+│   └── client.js             # 【client 半源码】面板/设置页/自动跳转（React.createElement 手写）
+├── scripts/
+│   └── build-client.mjs      # esbuild 打包：src/client.js → dist/client.js（CJS + ModuleLoader 包装）
+├── dist/                     # 构建产物（gitignore，发布/构建时生成）
+│
+├── test/
+│   ├── apply.mjs             # 冒烟：模块可加载 + client 可解析 + dist 存在
+│   ├── orchestration.test.mjs# 状态机 12 单测（占位占锁/revive/requeue/幽灵求助/上限…）
+│   └── bridge.test.mjs       # 快照桥 2 集成测试（Symbol.for 发布/读取）
+│
+├── broker/                   # ⚠️ 归档的 TS 参考实现（见 broker/README.md），不参与构建运行
+├── docs/
+│   ├── ARCHITECTURE.md       # 原始架构设计（已与实现同步）
+│   └── FORK-GUIDE.md         # 本文档
+└── AGENTS.md                 # 编排规格书（设计哲学 + 通信协议 + 禁止事项）
+```
+
+## 三、机制映射（什么功能 → 哪个文件 → 怎么实现）
+
+### 调度与编排
+
+| 功能 | 实现位置 | 原理 |
+|---|---|---|
+| 派发子代理（go_work） | `preset/tools/broker.mjs` `dispatchWork()` | 检查 `isBusy()` → 忙则 `enqueue()` 排队（返回 `work-*` 占位 id）；闲则 `beginSpawning()` 占位占锁（同步原子）→ `ctx.subagents.startContinuable()` 创建持久子会话 → `bindChild()` 绑定真实 childId |
+| 单线阻塞 | `broker.mjs` `Orchestration.currentMap` | 单槽 Map；`isBusy()` 到 `beginSpawning()` 之间无 await，Node 单线程下天然原子 |
+| 队列推进 | `broker.mjs` `advanceQueue()` | `subagent/end` 或 spawn 失败时触发：dequeue 队首 → dispatch；**失败自动 `requeueHead()` 回补**（fork 修复：任务不再蒸发） |
+| 求助挂起（need_help） | `broker.mjs` need_help 工具 | `suspend()` 标记 waiting + `reportFrom` 把求助单注入 Sisyphus 下一步。注：台账层挂起，无强制 interrupt（评估结论见第五节） |
+| 驳回/追问（continue） | `broker.mjs` continue 工具 | **先 `followup` 投递成功，后落账**（fork 修复时序病）；目标 waiting 则 resolveHelp+resume；目标已结束则 `revive()` 重新入册 + 恢复 sessionTypes 登记（fork 修复：结论不再丢失、单线不再被打破） |
+| 转发（forward） | `broker.mjs` forward 工具 | 同上「先投递后销账」；target 为工种名时等效 go_work，为 childId 时等效 continue |
+| 结论回流 | DSH 内核通知 + `broker.mjs` `subagent/end` | 子会话结束时内核通知父会话（broker 不重复注入）；broker 在 `subagent/end` 里 `finish()` 落账 → 清该子的求助单 → 删 sessionTypes → 推进队列。快速死亡的子会话（resolve 前就 end）归因到唯一 spawning 占位记录（fork 修复竞态冻结） |
+| 状态回收 | `broker.mjs` `agent/disposed` / `session/disposed` 钩子 | 子代理被销毁但错过 end 事件：兜底清槽防队列冻结；Sisyphus 会话被删：丢弃其排队任务 |
+
+### 模型与提示词
+
+| 功能 | 实现位置 | 原理 |
+|---|---|---|
+| 按工种绑模型 | `broker.mjs` `dispatchWork()`（创建时 `agentOptions`）+ `agent/request` waterfall（请求时兜底） | 创建前 `modelExists()` 用 `llm.listModels` 验证模型真实存在才应用；只缓存非空结果（fork 修复负缓存中毒） |
+| reasoningEffort | `broker.mjs` `supportedEfforts()` | 查 DSH 模型目录 `llm.resolveModelInfo`，**仅当模型实际支持该档位才设置**，否则留空走适配器默认（拒绝硬映射） |
+| Sisyphus persona/规则 | `broker.mjs` 两个 `systemPrompt.section` | 读 `prompts/sisyphus.md`，按 `## 编排规则` 切两半：前段进 `deployment:persona`、后段进 `dsh-my-go:orchestration`；子代理会话返回空串（靠 parentSession 判定） |
+| 子代理 persona | `broker.mjs` `dispatchWork()` | 把对应 `prompts/<type>.md` 全文包进 `<system-reminder>` 随首条 prompt 注入 |
+| DSV4P0813 两阶段 | `broker.mjs` `system-prompt/assemble` 监听 | 开启该开关的工种：phase-1 只放行 persona section + 白名单工具（`bash/pwsh/read/write/edit/glob/grep`，fork 已修正为 DSH 真实工具名）；首次 tool call 或 turn 结束后晋升放开全部 |
+| skill 隐藏 | `broker.mjs` `agent/created` | 主会话 `tools.restrict({ deny: ['skill'] })`，使 skill catalog 注入守门失效，节省主会话上下文；子代理保留 |
+
+### 安全与边界
+
+| 功能 | 实现位置 | 原理 |
+|---|---|---|
+| 编排权限 | `broker.mjs` `canOrchestrate()` | go_work/continue/forward 仅「无 parentSession 的会话」可调（工具层强制，不靠 prompt 自觉）；need_help 仅被跟踪的子代理可调 |
+| 星型拓扑闸（fork 新增） | `broker.mjs` + `lib/index.js` `agent/created` | 子代理在工具目录层被摘除 `subagent/subagent_fork/workflow/ralph/go_work/continue/forward`——无法私自派生孙代，也无法直接调度（与运行时守卫双保险） |
+| 沙箱外执行通道 | need_help `intent=execute` | 子代理把被拒命令发给 Sisyphus 代执行。注意：这是设计的权限提升通道，缓解靠 Sisyphus 的质检 prompt |
+
+### UI 与配置
+
+| 功能 | 实现位置 | 原理 |
+|---|---|---|
+| 树状图面板 | `src/client.js` `TreePanel` | `shell.overlay` 浮层 + 侧栏 🧭 开关；600ms 轮询 RPC `snapshot` 端点，seq 变化才重渲染（fork 修复：开关脱钩 + force bailout） |
+| 快照桥（fork 新增） | `broker.mjs` 发布 ↔ `lib/index.js` RPC 消费 | broker 把 `() => latestSnapshot` 挂到 `globalThis[Symbol.for('dsh-my-go.snapshot')]`；lib 的 RPC handler 优先实时读取（零副本），桥不在则回落自身状态机 |
+| 自动跳转 | `src/client.js` 定时器 | 子代理 running → `sessions.openSubagent()` 跟跳子会话；结束后 `sessions.open(parentSessionId)` 跳回（fork 补全跳回闭环 + 快照补上 parentSessionId） |
+| 设置页 | `src/client.js` `SettingsPage` ↔ `lib/index.js` RPC | 8 工种 × 4 字段；loadSettings 失败时 `draft=null` 禁止保存（fork 修复：不再一键清空配置）；saveSettings 空值 unset、显式 false 可表达（fork 修复） |
+| settings 合并 | `broker.mjs` / `lib/index.js` | 永远从 `baseBindings`（默认值+插件 config）起算合并 stored（fork 修复：WebUI 取消配置可回落）；`||` 语义统一（空串=未设置） |
+| preset 同步 | `lib/index.js` `ensurePresetInstalled()` | 版本标记文件 `.dsh-my-go-version`：版本不变则跳过（fork 修复：不再每次强制覆盖用户手改） |
+
+### 测试
+
+| 层 | 文件 | 覆盖 |
+|---|---|---|
+| 冒烟 | `test/apply.mjs` | 模块加载/导出面/client 语法/dist 存在 |
+| 单测 | `test/orchestration.test.mjs` | 状态机 12 例：占锁原子性、bindChild、finish 清求助、suspend/resume、revive、requeueHead、dropQueuedFor、history 200 上限、record/followupPrompt |
+| 集成 | `test/bridge.test.mjs` | mock cordis ctx 跑 `broker.apply()`，验证 Symbol.for 快照访问器发布且为实时 getter |
+
+## 四、fork 与上游的关系
+
+- `upstream` = [daizihan233/dsh-my-go](https://github.com/daizihan233/dsh-my-go)（本 fork 基于 v0.2.3 @ cf2d802）
+- 版本号规则：`上游版本-tisitan.N`；完整差异台账见 [CHANGELOG.md](../CHANGELOG.md)
+- 同步策略：定期 `git fetch upstream`，交集分析上游新提交与本 fork 补丁面，定点合并
+
+## 五、评估过但**未实施**的升级（含结论）
+
+| 候选 | 结论 | 原因 |
+|---|---|---|
+| need_help 改真 interrupt 硬挂起 | **暂缓** | `ctx.subagents.interrupt(childId, { kind: 'ancestor', agent: parentAgent })` API 存在（dsh-subagent/lib/types/continuation.d.ts:232），但中断时机（reportFrom 送达前杀回合会丢求助单）、恢复后模型如何感知被取消的 tool call，均需运行时实测验证。当前软挂起下：乱跑的子代理无法破坏队列（单线由状态机强制），仅浪费自身 token，残余风险可接受 |
+| isolate 服务 + `agentPresets.serviceFor` 官方桥 | **暂缓** | 需把 broker 拆成 isolate realm 服务行 + root 消费行（mount 审计强制 preset 服务入 isolate，而 broker 的 systemPrompt.section 必须留在 agent scope），重构面大且挂载行为无法离线验证。当前 Symbol.for 桥在拉取路径上功能等价（同进程、零副本、实时读） |
+| projection 推流替代 600ms 轮询 | **未来方向** | `session.append('mygo/state', 全量快照)` + `sessionProjections.register` + client `useProjection`（dsh-goal 官方范式），可解锁推流与冷会话回放。需 session 级事件写入，等运行时环境验证后实施 |

package/lib/index.js

@@ -18,7 +18,7 @@ export const name = 'dsh-my-go'
 
 export const inject = ['tools', 'subagents', 'systemPrompt', 'llm', 'settings']
 
-import { access, cp, mkdir } from 'node:fs/promises'
+import { access, cp, mkdir, readFile, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { homedir } from 'node:os'
@@ -30,7 +30,9 @@ const AGENT_TYPES = ['hermes', 'explore', 'librarian', 'looker', 'hephaestus', '
  * "MyGO!!!!! 模式" preset appears in the session picker after `dsh plugin
  * add dsh-my-go`. DSH discovers presets only from configured roots
  * (~/.dsh/.agent-presets/), never from node_modules, so the npm bundle must
- * copy its preset/ directory there. Idempotent: skips when already present.
+ * copy its preset/ directory there. Idempotent: synced only when the package
+ * version changes (marker file `.dsh-my-go-version`), so manual tweaks to the
+ * installed preset survive same-version reloads.
  * Failures are logged and swallowed — the host plugin must keep working even
  * when the preset copy is not possible.
  */
@@ -41,6 +43,17 @@ async function ensurePresetInstalled() {
     const dshHome = process.env.DSH_HOME || join(homedir(), '.dsh')
     const userPresetRoot = join(dshHome, '.agent-presets')
     const target = join(userPresetRoot, 'dsh-my-go')
+    const markerPath = join(target, '.dsh-my-go-version')
+    // Version marker: skip sync when the installed copy matches this package
+    let version = '0.0.0'
+    try {
+      const pkg = JSON.parse(await readFile(join(packageRoot, 'package.json'), 'utf-8'))
+      version = String(pkg.version ?? version)
+    } catch { /* fall through with default */ }
+    try {
+      const installed = (await readFile(markerPath, 'utf-8')).trim()
+      if (installed === version) return // already synced for this version
+    } catch { /* no marker → first install or legacy copy: sync below */ }
     await mkdir(userPresetRoot, { recursive: true })
     // Sync preset/ directory (composition + tools)
     const presetSource = join(packageRoot, 'preset')
@@ -53,7 +66,8 @@ async function ensurePresetInstalled() {
       await access(promptsSource)
       await cp(promptsSource, promptsTarget, { recursive: true, force: true })
     } catch { /* prompts/ optional — degrade gracefully */ }
-    console.log(`[dsh-my-go] preset synced to ${target}`)
+    await writeFile(markerPath, version, 'utf-8')
+    console.log(`[dsh-my-go] preset synced to ${target} (v${version})`)
   } catch (error) {
     console.error(`[dsh-my-go] could not sync preset: ${String(error)}`)
   }
@@ -65,13 +79,6 @@ function agentLabel(type, summary) {
   return `${AGENT_TYPE_PREFIX}${type}${summary ? `: ${summary}` : ''}`
 }
 
-function parseAgentType(label) {
-  if (typeof label !== 'string') return undefined
-  const match = /^dsh-my-go:([a-z-]+)/.exec(label)
-  if (!match) return undefined
-  return AGENT_TYPES.includes(match[1]) ? match[1] : undefined
-}
-
 /** Default bindings per AGENTS.md. Provider stays unset for light agents so
  * they inherit Sisyphus's route; heavy agents pin the octopus gateway.
  * reasoningEffort is only ever applied when the exact model supports that
@@ -215,12 +222,51 @@ class Orchestration {
       updatedAt: Date.now(),
     }
     this.currentMap.delete(childId)
+    this.clearHelpFor(childId)
     this.history = [...this.history, done]
     if (this.history.length > 200) this.history = this.history.slice(-200)
     this.emit()
     return done
   }
 
+  clearHelpFor(childId) {
+    let removed = false
+    for (const [id, help] of this.helpRequests) {
+      if (help.childId === childId) {
+        this.helpRequests.delete(id)
+        removed = true
+      }
+    }
+    if (removed) this.emit()
+    return removed
+  }
+
+  requeueHead(work) {
+    if (!work) return
+    this.queue.unshift(work)
+    this.emit()
+  }
+
+  dropQueuedFor(parentId) {
+    const before = this.queue.length
+    this.queue = this.queue.filter((w) => w.parentId !== parentId)
+    if (this.queue.length !== before) this.emit()
+    return before - this.queue.length
+  }
+
+  /** Move a done/failed history record back into currentMap as running (revive via continue/forward). */
+  revive(childId) {
+    if (this.currentMap.has(childId)) return this.currentMap.get(childId)
+    const idx = this.history.findIndex((r) => r.childId === childId)
+    if (idx < 0) return undefined
+    const rec = this.history[idx]
+    const next = { ...rec, status: 'running', updatedAt: Date.now() }
+    this.history = [...this.history.slice(0, idx), ...this.history.slice(idx + 1)]
+    this.currentMap.set(childId, next)
+    this.emit()
+    return next
+  }
+
   abort(childId) {
     this.currentMap.delete(childId)
     this.emit()
@@ -255,7 +301,10 @@ export async function apply(ctx, config = {}) {
   void ensurePresetInstalled()
   const orchestration = new Orchestration()
   const sessionTypes = new Map()
-  let bindings = { ...defaultBindings(), ...(config.bindings ?? {}) }
+  // 合并基线：默认值 + 插件 config。settings 覆盖永远从基线起算，
+  // 这样 WebUI 取消某字段后能正确回落默认，而不是残留旧的已合并值。
+  const baseBindings = { ...defaultBindings(), ...(config.bindings ?? {}) }
+  let bindings = { ...baseBindings }
   const bindSisyphus = config.bindSisyphus === true
 
   // Track authorized orchestrators: any agent on this preset that is NOT
@@ -297,14 +346,14 @@ export async function apply(ctx, config = {}) {
       )
       const stored = settings.get('dsh-my-go')
       if (stored && typeof stored === 'object') {
-        const merged = { ...bindings }
+        const merged = { ...baseBindings }
         for (const key of ['sisyphus', ...AGENT_TYPES]) {
           const row = stored[key]
           if (row && typeof row === 'object') {
             merged[key] = {
-              provider: row.provider ?? merged[key]?.provider,
-              model: row.model ?? merged[key]?.model,
-              reasoningEffort: row.reasoningEffort ?? merged[key]?.reasoningEffort,
+              provider: row.provider || merged[key]?.provider,
+              model: row.model || merged[key]?.model,
+              reasoningEffort: row.reasoningEffort || merged[key]?.reasoningEffort,
               dsv4p0813: row.dsv4p0813 ?? merged[key]?.dsv4p0813 ?? false,
             }
           }
@@ -315,14 +364,14 @@ export async function apply(ctx, config = {}) {
         if (ns !== 'dsh-my-go') return
         const next = settings.get('dsh-my-go')
         if (next && typeof next === 'object') {
-          const merged = { ...bindings }
+          const merged = { ...baseBindings }
           for (const key of ['sisyphus', ...AGENT_TYPES]) {
             const row = next[key]
             if (row && typeof row === 'object') {
               merged[key] = {
-                provider: row.provider ?? merged[key]?.provider,
-                model: row.model ?? merged[key]?.model,
-                reasoningEffort: row.reasoningEffort ?? merged[key]?.reasoningEffort,
+                provider: row.provider || merged[key]?.provider,
+                model: row.model || merged[key]?.model,
+                reasoningEffort: row.reasoningEffort || merged[key]?.reasoningEffort,
                 dsv4p0813: row.dsv4p0813 ?? merged[key]?.dsv4p0813 ?? false,
               }
             }
@@ -339,9 +388,11 @@ export async function apply(ctx, config = {}) {
   // NOT harness.handle, which is reserved for dynamic cordis plugins) ──────
   let latestSnapshot = null
   let snapshotSeq = 0
+  // Track the last orchestrator session for queue fallback and client auto-jump.
+  let lastOrchestratorSessionId = null
   const bump = () => {
     snapshotSeq += 1
-    latestSnapshot = { seq: snapshotSeq, ...orchestration.snapshot() }
+    latestSnapshot = { seq: snapshotSeq, parentSessionId: lastOrchestratorSessionId, ...orchestration.snapshot() }
   }
   orchestration.onChange(() => bump())
 
@@ -354,7 +405,11 @@ export async function apply(ctx, config = {}) {
     // channel = "/dsh-my-go", endpoints = "snapshot" | "listModels"
     rpc.handle('/dsh-my-go', async (endpoint, payload) => {
       if (endpoint === 'snapshot') {
-        return { ok: true, value: latestSnapshot ?? { seq: 0, current: null, queue: [], helpRequests: [], history: [] } }
+        // 优先读 agent 平面 broker 发布的真实编排快照（Symbol.for 全局桥）；
+        // 桥不存在时回落到本实例自己的状态机（preset 未装配的部署形态）。
+        const shared = globalThis[Symbol.for('dsh-my-go.snapshot')]
+        const value = typeof shared === 'function' ? shared() : latestSnapshot
+        return { ok: true, value: value ?? { seq: 0, current: null, queue: [], helpRequests: [], history: [] } }
       }
       if (endpoint === 'listModels') {
         const llm = ctx.get('llm')
@@ -397,7 +452,7 @@ export async function apply(ctx, config = {}) {
           for (const type of agentTypes) {
             for (const field of fields) {
               const val = draft[type]?.[field]
-              if (val === undefined || val === null || val === '' || val === false) {
+              if (val === undefined || val === null || val === '') {
                 ops.push({ op: 'unset', path: [type, field] })
               } else {
                 ops.push({ op: 'set', path: [type, field], value: val })
@@ -415,17 +470,33 @@ export async function apply(ctx, config = {}) {
   })
 
   // ── internal go_work implementation (shared by the tool, forward, queue) ─
+  // 队列推进：取出队首并派发；派发失败时回补队首——任务不蒸发、队列不停摆。
+  function advanceQueue(parentHint) {
+    if (orchestration.isBusy()) return
+    const work = orchestration.dequeue()
+    if (!work) return
+    const agents = ctx.get('agents')
+    const parentAgent = (work.parentId && agents ? agents.get(work.parentId) : undefined) ?? parentHint
+    void dispatchWork(work.agentType, work.prompt, parentAgent, undefined).catch((error) => {
+      orchestration.requeueHead(work)
+      bump()
+      console.error('[dsh-my-go] queued dispatch failed, task requeued:', error)
+    })
+  }
+
   async function dispatchWork(agentType, prompt, parent, signal) {
     if (!AGENT_TYPES.includes(agentType)) throw new Error(`unknown agent type: ${String(agentType)}`)
     const binding = bindings[agentType] ?? {}
     // Parent may be absent during queue advancement (agent object not retained);
-    // fall back to the live Sisyphus root session so delegation still works.
+    // fall back to the last orchestrator session so delegation still works.
+    // (Do NOT use agents.roots()[0] — that leaks queued work into other sessions.)
     if (!parent) {
       const agents = ctx.get('agents')
-      const root = agents?.roots?.()?.find((agent) => agent && typeof agent.id === 'string')
-      if (root) parent = root
+      const fallback = lastOrchestratorSessionId ? agents?.get?.(lastOrchestratorSessionId) : undefined
+      if (fallback) parent = fallback
     }
     if (!parent) throw new Error('go_work requires a live parent agent to delegate from')
+    lastOrchestratorSessionId = parent.id
     if (orchestration.isBusy()) {
       const workId = orchestration.enqueue(agentType, prompt, parent?.id)
       bump()
@@ -455,6 +526,8 @@ export async function apply(ctx, config = {}) {
     } catch (error) {
       orchestration.abort(placeholder.childId)
       bump()
+      // 槽位已腾出：立即推进队首，避免后续排队任务永久等待
+      advanceQueue(parent)
       throw new Error(`go_work failed: ${String(error)}`)
     }
   }
@@ -468,6 +541,7 @@ export async function apply(ctx, config = {}) {
       ...AGENT_TYPES.map((t) => `- ${t}: ${describeAgent(t)}`),
       'Single-line blocking: if a sub-agent is already running, this task is queued and starts when the current one finishes.',
       'The result contains a childId you keep for later continue/forward operations.',
+      'If the task was queued (queued=true), the returned id is a queue placeholder (work-*), NOT a childId — once dispatched, find the real childId via orchestration_status.',
     ].join('\n'),
     parameters: {
       type: 'object',
@@ -528,17 +602,33 @@ export async function apply(ctx, config = {}) {
       if (!parent) throw new Error('continue requires a calling agent (exec.agent was undefined)')
       if (!canOrchestrate(parent)) throw new Error('continue is reserved for orchestrator sessions (agents without parentSession)')
       const record = orchestration.record(args.id)
-      if (!record) throw new Error(`unknown sub-agent id: ${String(args.id)}`)
-      if (record.status === 'waiting') {
-        for (const help of orchestration.snapshot().helpRequests) {
-          if (help.childId === record.childId) orchestration.resolveHelp(help.id)
+      if (!record) {
+        const queued = orchestration.snapshot().queue.find((w) => w.id === args.id)
+        if (queued) {
+          throw new Error(`task ${String(args.id)} (${queued.agentType}) is still queued — wait for dispatch, then use its real childId (see orchestration_status)`)
         }
-        orchestration.resume(record.childId)
+        throw new Error(`unknown sub-agent id: ${String(args.id)}`)
       }
+      const isFinished = !orchestration.currentMap.has(record.childId)
+      if (isFinished && orchestration.isBusy()) {
+        throw new Error('another sub-agent is currently running; wait for it to finish before reviving a completed sub-agent (single-line blocking)')
+      }
+      // 先投递，成功后再落账：投递失败不会留下假 running、也不会弄丢求助单
       const messageId = await ctx.subagents.followup(parent, record.childId, [{ type: 'text', text: args.prompt }], {
         source: { kind: 'coordinator', form: 'relay', senderSessionId: parent.id },
         signal: exec?.signal,
       })
+      if (record.status === 'waiting') {
+        for (const help of orchestration.snapshot().helpRequests) {
+          if (help.childId === record.childId) orchestration.resolveHelp(help.id)
+        }
+        orchestration.resume(record.childId)
+      } else if (isFinished) {
+        // 驳回/追问一个已结束的子智能体：重新入册并恢复类型登记，
+        // 否则它游离在单线阻塞之外，且再次结束时结论会被静默丢弃
+        orchestration.revive(record.childId)
+        sessionTypes.set(record.childId, record.agentType)
+      }
       orchestration.followupPrompt(record.childId, args.prompt)
       bump()
       return { accepted: true, messageId }
@@ -639,19 +729,31 @@ export async function apply(ctx, config = {}) {
       if (!help) throw new Error(`unknown help request id: ${String(args.from)}`)
       const prompt = help.content
       const target = String(args.target)
-      orchestration.resolveHelp(help.id)
       if (AGENT_TYPES.includes(target)) {
         // Dispatch a new sub-agent of that type.
         const result = await dispatchWork(target, prompt, parent, exec?.signal)
+        orchestration.resolveHelp(help.id) // 投递成功后才销账，失败则求助单保留
         bump()
         return { kind: 'go_work', targetId: String(result?.childId ?? ''), resolved: true }
       }
+      const record = orchestration.record(target)
+      if (!record) throw new Error(`unknown sub-agent id: ${target}`)
+      const isFinished = !orchestration.currentMap.has(target)
+      if (isFinished && orchestration.isBusy()) {
+        throw new Error('another sub-agent is currently running; wait for it to finish before forwarding to a completed sub-agent (single-line blocking)')
+      }
       const messageId = await ctx.subagents.followup(parent, target, [{ type: 'text', text: prompt }], {
         source: { kind: 'coordinator', form: 'relay', senderSessionId: parent.id },
         signal: exec?.signal,
       })
       orchestration.followupPrompt(target, prompt)
-      orchestration.resume(target)
+      if (record.status === 'waiting') {
+        orchestration.resume(target)
+      } else if (isFinished) {
+        orchestration.revive(target)
+        sessionTypes.set(target, record.agentType)
+      }
+      orchestration.resolveHelp(help.id)
       bump()
       return { kind: 'continue', targetId: messageId, resolved: true }
     },
@@ -766,11 +868,18 @@ export async function apply(ctx, config = {}) {
         const list = await llm.listModels(key)
         for (const m of list) set.add(m.id)
       } catch { /* provider may not support listing */ }
-      modelCache.set(key, set)
+      // 只缓存非空结果：瞬时失败/空列表不永久缓存（负缓存会让模型绑定
+      // 在本进程生命周期内静默失效），留待下次请求重试
+      if (set.size > 0) modelCache.set(key, set)
     }
     return set.has(String(model))
   }
 
+  // 注意：此处刻意【不】挂 agent/created 钩子。lib 是 global 层插件，该事件
+  // 会收到 profile 内【所有】会话（含非 MyGO 会话）——skill 隐藏与拓扑闸只应
+  // 作用于 MyGO preset 会话，由 preset 作用域的 broker.mjs 负责（standing scope
+  // 的 listener 只接收 join 它的 agent 的事件）。在此全局挂钩会误伤其他 preset。
+
   ctx.on('agent/request', async (payload, next) => {
     const seed = await next()
     const agent = payload?.agent
@@ -801,11 +910,47 @@ export async function apply(ctx, config = {}) {
     return nextConfig
   })
 
+  // ── 生命周期清理：会话/代理销毁时回收编排状态，防止跨会话泄漏 ──────────
+  ctx.on('agent/disposed', ({ agent }) => {
+    const id = agent?.id
+    if (!id) return
+    const tracked = sessionTypes.delete(id)
+    if (orchestration.currentMap.has(id)) {
+      // 子代理被销毁但错过了 subagent/end：兜底清槽，否则队列永久冻结
+      orchestration.clearHelpFor(id)
+      orchestration.abort(id)
+      bump()
+      advanceQueue()
+    } else if (tracked) {
+      bump()
+    }
+  })
+
+  ctx.on('session/disposed', (session) => {
+    const id = session?.id
+    if (!id) return
+    if (id === lastOrchestratorSessionId) {
+      // Sisyphus 主会话被删除：丢弃其排队任务，避免悬挂到永远不会来的父会话
+      lastOrchestratorSessionId = null
+      orchestration.dropQueuedFor(id)
+      bump()
+    }
+  })
+
   // ── conclusion injection + queue advancement on subagent/end ────────────
   ctx.on('subagent/end', (info) => {
     const childId = info?.id
-    const type = sessionTypes.get(childId)
-    if (type === undefined) return
+    let type = sessionTypes.get(childId)
+    if (type === undefined) {
+      // 竞态兜底：快速失败的子会话可能在 startContinuable resolve 之前就触发
+      // subagent/end（此时 sessionTypes 尚未登记）。单线阻塞下至多存在一条
+      // spawning 记录，可安全归因到它，否则会永久卡在 spawning/running 冻结队列。
+      const spawning = [...orchestration.currentMap.values()].find((r) => r.status === 'spawning')
+      if (!spawning) return
+      type = spawning.agentType
+      orchestration.bindChild(spawning.childId, childId)
+      console.warn('[dsh-my-go] subagent/end arrived before spawn resolved; attributed to spawning record', childId)
+    }
     const blocks = info?.lastAssistantMessage ?? []
     const text = blocks
       .filter((block) => block?.type === 'text' && typeof block.text === 'string')
@@ -816,16 +961,7 @@ export async function apply(ctx, config = {}) {
     sessionTypes.delete(childId)
     bump()
     // Advance queue.
-    if (orchestration.snapshot().queue.length > 0 && !orchestration.isBusy()) {
-      const work = orchestration.dequeue()
-      if (work) {
-        // Resolve the recorded parent agent (the Sisyphus session) and
-        // dispatch the next queued work through the same internal path.
-        const agents = ctx.get('agents')
-        const parentAgent = work.parentId && agents ? agents.get(work.parentId) : undefined
-        void dispatchWork(work.agentType, work.prompt, parentAgent, undefined).catch(() => undefined)
-      }
-    }
+    advanceQueue()
   })
 
   return () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-my-go",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "DSH plugin: Sisyphus agent orchestration — star topology, single-line blocking, 7 specialist sub-agents (Hermes/Explore/Librarian/Looker/Hephaestus/Prometheus/Oracle) with per-type model binding, go_work/continue/need_help/forward communication tools, Web UI tree panel and settings.",
   "author": "daizihan233",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "build": "bun run build:client",
     "build:client": "node scripts/build-client.mjs",
     "typecheck": "tsc --noEmit",
-    "test": "node test/apply.mjs"
+    "test": "node test/apply.mjs && node --test test/orchestration.test.mjs test/bridge.test.mjs"
   },
   "dsh": {
     "bundle": { "patch": "./cordis.patch.yml" },

package/preset/agent.cordis.yml

@@ -162,3 +162,11 @@
   config:
     fetch: false
     searchTimeoutMs: 60000
+
+# ── tool mask ────────────────────────────────────────────────────────────────
+# Hides Rei-persona memory tools and the OpenCode bridge from this preset's
+# catalog — applies to Sisyphus and every sub-agent on the preset (synced from
+# the `nova` preset recipe). Mask list lives in ./tool-mask.mjs (per-name
+# try/catch, so an absent tool cannot fail the mount).
+- id: tool-mask
+  name: ./tool-mask.mjs

package/preset/tool-mask.mjs

@@ -0,0 +1,27 @@
+// MyGO preset tool mask: hide Rei-persona memory tools and the OpenCode
+// bridge from this preset's catalog (Sisyphus AND sub-agents alike — the
+// mask applies at preset scope). Synced from the `nova` preset recipe.
+// Per-name try/catch: a tool absent from this deployment throws on restrict
+// and is skipped (with a visible warning); the rest still apply and the
+// preset mount never fails because of the mask.
+export const inject = ['tools'];
+
+const DENY = [
+  'mcp__vcp__daily_note_create_for_rei',
+  'mcp__vcp__daily_note_update_for_rei',
+  'mcp__vcp__light_memo_search_for_rei',
+  'mcp__vcp__rei_memo_write',
+  'mcp__vcp__opencode_task',
+  'mcp__vcp__opencode_list_sessions',
+  'mcp__vcp__opencode_delete_session',
+];
+
+export function apply(ctx) {
+  for (const name of DENY) {
+    try {
+      ctx.tools.restrict({ deny: [name] });
+    } catch (error) {
+      console.warn(`[dsh-my-go] tool-mask: could not deny "${name}" (absent or reserved): ${String(error)}`);
+    }
+  }
+}