dsh-agent-board 1.9.0 → 1.9.2

package/test/core.test.mjs

@@ -8,6 +8,7 @@ import os from 'node:os'
 import path from 'node:path'
 import zlib from 'node:zlib'
 import { spawnSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 import * as core from '../lib/core.mjs'
 // 粒度治理（软闸门）住在 lib/policy.mjs（策略层，纯函数）、usage 聚合住在 lib/usage.mjs，
 // 均由 index.mjs 薄壳 re-export（对外契约不变），这里仍从 index.mjs 导入直接断言
@@ -19,7 +20,8 @@ import { createSession, isFullSessionId } from '../lib/session.mjs'
 import { createDispatch } from '../lib/dispatch.mjs'
 import { createNotify } from '../lib/notify.mjs'
 // host 端源码拼接（Phase 2 模块化后：薄壳 index.mjs + lib/*.mjs 领域模块），供源码级接线断言
-const HOST_SOURCES = ['../index.mjs', '../lib/policy.mjs', '../lib/usage.mjs', '../lib/session.mjs', '../lib/store.mjs', '../lib/notify.mjs', '../lib/dispatch.mjs', '../lib/rpc.mjs']
+// 拆分第 6 刀（task-mvt8c1yx-6）：角色结算搬入 lib/settle.mjs——拼接清单补入 settle.mjs（接线断言随源码重指）
+const HOST_SOURCES = ['../index.mjs', '../lib/policy.mjs', '../lib/usage.mjs', '../lib/session.mjs', '../lib/store.mjs', '../lib/notify.mjs', '../lib/dispatch.mjs', '../lib/settle.mjs', '../lib/rpc.mjs']
 function hostSrc() { return HOST_SOURCES.map(function (f) { return readFileSync(new URL(f, import.meta.url), 'utf8') }).join('\n') }
 
 function mkTask(over) { return Object.assign({ id: 't1', title: 'T', description: '', status: 'pending', priority: 'medium', tags: [], parentId: null, assignMode: 'auto', assignee: null, context: { instructions: '' }, acceptance: '', dependsOn: [], pipeline: 'full', claimedBy: null, claimedAt: null, createdAt: '2026-01-01T00:00:00Z', resolvedAt: null, history: [], messages: [] }, over || {}) }
@@ -1040,6 +1042,82 @@ test('parsePlanFiles: 剥行尾注释——全角/半角括号尾巴 + 「 —
   assert.deepEqual(core.planOutsideTouches(['lib/core.mjs'], core.parsePlanFiles('计划改动：lib/core.mjs（L75-L91 语义注释）')), [])
 })
 
+// 像路径判定（task-mvqfl7in，n-mvqfiofr0kt9 误报实证：注释剥离只救带括号/破折号的说明行，
+// 无路径特征的纯散文行仍整行被当文件参与 touches 比对 → 假越界警示，Worker 被迫改纯路径清单才过）
+test('parsePlanFiles: 像路径判定——纯散文行直接丢弃；路径行/裸扩展名行/反斜杠行/尾斜杠行不受影响；混合清单只留路径；全散文=空清单重报语义', () => {
+  // 纯散文行（无 / 无 \ 无扩展名）不进清单——昨天的实证误报形态：说明文字整行被当文件比对
+  assert.deepEqual(core.parsePlanFiles('计划改动：这是一段纯说明文字'), [])
+  assert.deepEqual(core.parsePlanFiles('计划改动：\n- 调研文件清单\n- 只动解析不动闸口比对'), [])
+  // 裸扩展名行（无 / 但以代码扩展名结尾）不受影响——像路径判定或一条件的扩展名分支（宽正则）
+  assert.deepEqual(core.parsePlanFiles('计划改动：README.md'), ['README.md'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：plan.mjs、CHANGELOG.md'), ['plan.mjs', 'CHANGELOG.md'])
+  // Windows 反斜杠目录行（无扩展名，归一前含分隔符证据）不受影响——判定在归一前做
+  assert.deepEqual(core.parsePlanFiles('计划改动：D:\\deepseek-work\\lib'), ['D:/deepseek-work/lib'])
+  // 尾部斜杠目录行（`lib/` 归一为裸目录名）不受影响——分隔符证据在归一前，与既有归一断言同口径
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/'), ['lib'])
+  // 混合清单：散文行丢弃、路径行保留，保序去重
+  assert.deepEqual(core.parsePlanFiles('计划改动：\n- 调研文件清单\n- lib/core.mjs\n- 闸口解析补刀\n- lib/core.mjs'), ['lib/core.mjs'])
+  // 误报直接复现：路径行+散文行同报，散文行不再触发假越界
+  assert.deepEqual(core.planOutsideTouches(['lib/core.mjs'], core.parsePlanFiles('计划改动：lib/core.mjs（语义注释）\n这是一段纯说明文字')), [])
+  // 全散文条目全被丢光 = 空数组 → 调用方既有「有前缀但零路径」重报提示语义（rpc.mjs planGateApply 空清单分支）
+  assert.deepEqual(core.planOutsideTouches(['lib/**'], core.parsePlanFiles('计划改动：\n- 纯说明行一\n- 纯说明行二')), [])
+})
+
+// 像路径判定收紧（task-mvr44s0y，n-mvqfiofr0kt9 追加样本）：全角标点拆段 + 含路径碎片散文段两类残留根治
+test('parsePlanFiles: 收紧——全角分隔长说明段不进清单；含路径碎片的散文段整条丢弃（选定语义：取前缀或丢弃二选一取丢弃）；路径优先混合行截到路径前缀；引号包裹路径含空格不受影响', () => {
+  // ① 全角标点拆段（n-mvqfiofr0kt9 追加样本）：中文逗号分隔的长说明段（散文在前、路径碎片在后）整段不进清单
+  assert.deepEqual(core.parsePlanFiles('计划改动：本次重构 lib/core.mjs 的 parsePlanFiles，补全测试断言，顺带更新 README'), [])
+  assert.deepEqual(core.parsePlanFiles('计划改动：修复 lib/core.mjs 的解析，更新 test/x.mjs 的断言'), [])
+  // 全散文 = 空数组 → rpc.mjs 既有「未解析到路径 → 重报提示」自纠正语义
+  assert.deepEqual(core.planOutsideTouches(['lib/**'], core.parsePlanFiles('计划改动：已完成调研，计划只动解析器，比对逻辑不动')), [])
+  // 混合清单：全角分隔散文段丢弃、正常路径行保留
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/core.mjs\n修 parsePlanFiles 的解析，补全测试断言，更新 README'), ['lib/core.mjs'])
+  // ② 含路径碎片的散文段（n-mvqfiofr0kt9 追加样本）：说明在前、路径碎片在中 → 整条丢弃（选定语义锁死）
+  assert.deepEqual(core.parsePlanFiles('计划改动：故障层复用 test/helpers/fault-provider.mjs 可变目录'), [])
+  // 全角标点粘连散文（无空格）同理丢弃——截断类含全角冒号
+  assert.deepEqual(core.parsePlanFiles('计划改动：故障层：复用test/helpers/fault-provider.mjs'), [])
+  // 路径优先混合行：「路径+空格+说明」「路径+全角标点+说明」截到首个空白/全角标点前的路径前缀
+  assert.deepEqual(core.parsePlanFiles('计划改动：test/helpers/fault-provider.mjs 故障层可变目录复用点'), ['test/helpers/fault-provider.mjs'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/core.mjs—解析器'), ['lib/core.mjs'])
+  // 截出的路径前缀参与 touches 比对：散文段不触发假越界，路径前缀正常判定
+  assert.deepEqual(core.planOutsideTouches(['test/helpers/**'], core.parsePlanFiles('计划改动：test/helpers/fault-provider.mjs 故障层可变目录')), [])
+  assert.deepEqual(core.planOutsideTouches(['lib/**'], core.parsePlanFiles('计划改动：lib/core.mjs 修复点，test/x.mjs 另行处理')), ['test/x.mjs'])
+  // 引号包裹路径含空格不受影响（「除非引号包裹」例外分支：取首对反引号内容）
+  assert.deepEqual(core.parsePlanFiles('计划改动：`my docs/a b.md`（注释）'), ['my docs/a b.md'])
+})
+
+// 解析伪影收紧 + 扩权边界正向锁（task-mvtz2jjq，n-mvtejrusnhi6 生产双病案）：「仲裁 expandTouches
+// 放行后重派仍被拦」的真凶不是闸口不认 extraTouches（rpc.mjs 早已读 effectiveTouches），而是
+// parsePlanFiles 的两类解析伪影被误判路径、残片永远不在边界内 → 二次拦截。
+test('parsePlanFiles: 伪影判非路径（正则残片 + 含半角斜杠的中文散文片）；既有真路径零回归；effectiveTouches 正向锁', () => {
+  // ① 正则/代码残片（生产实证片段）：以 '/' 开头且其后含 '(' 或 '\' 转义 → 非路径
+  assert.deepEqual(core.parsePlanFiles('计划改动：/if \\(isHungKillFailure(x)\\)/ 判定点'), [])
+  // 哨兵证据必须在「首空白截断」前采：截断后只剩 '/if'（旧判定含 '/' 即入选 → 假越界），同行真路径仍保留
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/core.mjs\n/if \\(isHungKillFailure(x)\\)/ 判定点'), ['lib/core.mjs'])
+  assert.deepEqual(core.planOutsideTouches(['lib/**'], core.parsePlanFiles('计划改动：/if \\(isHungKillFailure(x)\\)/ 判定点')), [])
+  // ② 含半角斜杠的中文散文片（生产实证片段）：含 CJK 字符的 token 判非路径
+  assert.deepEqual(core.parsePlanFiles('计划改动：调用点/接线断言仍锁'), [])
+  assert.deepEqual(core.parsePlanFiles('计划改动：调用点/接线断言仍锁 —— 说明'), [])
+  assert.deepEqual(core.planOutsideTouches(['lib/**'], core.parsePlanFiles('计划改动：调用点/接线断言仍锁')), [])
+  // 混合清单：残片丢弃、真路径保序去重（与既有收紧断言同口径）
+  assert.deepEqual(core.parsePlanFiles('计划改动：\n- 调用点/接线断言仍锁\n- lib/core.mjs\n- /if \\(x\\)/ 残片'), ['lib/core.mjs'])
+  // ③ 既有真路径零回归：相对/裸扩展名/绝对/反斜杠/尾斜杠 全不受影响
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/core.mjs'), ['lib/core.mjs'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：README.md、plan.mjs'), ['README.md', 'plan.mjs'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：/usr/local/lib/x.mjs'), ['/usr/local/lib/x.mjs'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：D:\\deepseek-work\\lib'), ['D:/deepseek-work/lib'])
+  assert.deepEqual(core.parsePlanFiles('计划改动：lib/'), ['lib'])
+  // ④ 正向锁：有效边界 = touches ∪ extraTouches → 扩权文件过闸（闸口全链就是这条组合：
+  // rpc.planGateApply = core.effectiveTouches → core.parsePlanFiles → core.planOutsideTouches）
+  var tArb = { id: 'task-arb', touches: ['src/a.mjs'], extraTouches: ['src/extra.mjs'] }
+  var planArb = core.parsePlanFiles('计划改动：src/a.mjs\nsrc/extra.mjs')
+  assert.deepEqual(planArb, ['src/a.mjs', 'src/extra.mjs'])
+  assert.deepEqual(core.effectiveTouches(tArb), ['src/a.mjs', 'src/extra.mjs'])
+  assert.deepEqual(core.planOutsideTouches(core.effectiveTouches(tArb), planArb), [], '扩权文件在有效边界内 → 零越界（扩权即边界）')
+  // 反证：不并 extraTouches 时报越界——证明这条锁真在钉 effectiveTouches（否则断言恒真无意义）
+  assert.deepEqual(core.planOutsideTouches(tArb.touches, planArb), ['src/extra.mjs'])
+})
+
 test('touchCovers: 单向覆盖——touch 模式 ⊇ 计划文件（与 matchOne 对称语义方向相反）', () => {
   assert.equal(core.touchCovers('lib/core.mjs', 'lib/core.mjs'), true)   // 精确
   assert.equal(core.touchCovers('lib/core.mjs', 'lib/rpc.mjs'), false)
@@ -2121,10 +2199,10 @@ test('pushRejection: 同事件判重（同时间戳/同前缀不双推）+ 空
 
 test('驳回全量带回接线（源码级）：三条驳回路径都调 pushRejection + messages 通道在位', () => {
   const rpc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
-  const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
   assert.equal((rpc.match(/pushRejection\(t, /g) || []).length, 3) // board_verdict 工具 + verify-task RPC + task_verify 工具
-  assert.match(dsp, /pushRejection\(t, vsecs\.verifySummary, vsecs\.checks, t\.verification\.at, String\(rec\.id\)\)/)
+  assert.match(settleSrc, /pushRejection\(t, vsecs\.verifySummary, vsecs\.checks, t\.verification\.at, String\(rec\.id\)\)/) // Verifier 文本结算随拆分第 6 刀重指 settle 源
   assert.equal((hostSrc().match(/pushRejection\(t, /g) || []).length, 4) // 三条路径 + Verifier 文本结算
   assert.match(coreSrc, /export function pushRejection/)
   assert.match(coreSrc, /kind: 'rejection'/)
@@ -2611,21 +2689,22 @@ test('README 双份同步记录 Token 口径（总量主显 / 近 7 天 / 有效
 })
 
 test('Token run 级留账：accumulateRunUsage 把本次用量写回对应 t.runs 条目（源码级断言）', () => {
-  const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  // 拆分第 7 刀（task-mvt8c1yx-7，仲裁扩权放行）：accumulateRunUsage 随源码搬至 lib/settle.mjs——断言随源码重指 settle 源
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   // 五分量原样写回 runs 条目：任何维度（按天/按模型/按阶段）都能从 runs 精确重建，不必回头猜
-  assert.match(dsp, /if \(Array\.isArray\(t\.runs\)\)/)
-  assert.match(dsp, /if \(String\(t\.runs\[ri\] && t\.runs\[ri\]\.id\) === String\(rec\.id\)\)/)
-  assert.match(dsp, /t\.runs\[ri\]\.usage = \{ input: u\.input \|\| 0, output: u\.output \|\| 0, cacheRead: u\.cacheRead \|\| 0, cacheWrite: u\.cacheWrite \|\| 0, total: u\.total \|\| 0 \}/)
-  assert.match(dsp, /break/) // 命中即停（同一 runId 只记一次）
+  assert.match(settleSrc, /if \(Array\.isArray\(t\.runs\)\)/)
+  assert.match(settleSrc, /if \(String\(t\.runs\[ri\] && t\.runs\[ri\]\.id\) === String\(rec\.id\)\)/)
+  assert.match(settleSrc, /t\.runs\[ri\]\.usage = \{ input: u\.input \|\| 0, output: u\.output \|\| 0, cacheRead: u\.cacheRead \|\| 0, cacheWrite: u\.cacheWrite \|\| 0, total: u\.total \|\| 0 \}/)
+  assert.match(settleSrc, /break/) // 命中即停（同一 runId 只记一次）
   // 倒序查找 + 找不到就跳过：runs 条目由 recordRunHistory 先行写入、closeRunHistory 更新结局，正常必存在
-  assert.match(dsp, /for \(var ri = t\.runs\.length - 1; ri >= 0; ri--\)/)
+  assert.match(settleSrc, /for \(var ri = t\.runs\.length - 1; ri >= 0; ri--\)/)
   // 有效消耗口径单点定义（host 侧），byDay 双指标记账与它同源
-  assert.match(dsp, /function effectiveOf\(u\) \{/)
-  assert.match(dsp, /return \(u\.input \|\| 0\) \+ \(u\.output \|\| 0\) \+ \(u\.cacheWrite \|\| 0\)/)
-  assert.match(dsp, /var eff = effectiveOf\(u\)/)
+  assert.match(settleSrc, /function effectiveOf\(u\) \{/)
+  assert.match(settleSrc, /return \(u\.input \|\| 0\) \+ \(u\.output \|\| 0\) \+ \(u\.cacheWrite \|\| 0\)/)
+  assert.match(settleSrc, /var eff = effectiveOf\(u\)/)
   // byDay 双指标：总 t / 有效 e 各自累加；老 number 形态脏值就地收敛成对象（不把老字段形态写坏）
-  assert.match(dsp, /if \(!cell \|\| typeof cell !== 'object'\) cell = \{ t: Number\(cell\) \|\| 0, e: 0 \}/)
-  assert.match(dsp, /t\.usage\.byDay\[dk\] = cell/)
+  assert.match(settleSrc, /if \(!cell \|\| typeof cell !== 'object'\) cell = \{ t: Number\(cell\) \|\| 0, e: 0 \}/)
+  assert.match(settleSrc, /t\.usage\.byDay\[dk\] = cell/)
 })
 
 test('readRunUsage: run 不存在 / 日志目录不可读 → null（优雅降级，不抛错）', () => {
@@ -2680,9 +2759,10 @@ test('Token 日账接线：dispatch 记 byDay 双指标（本地日）+ 仪表
   assert.match(host, /cell\.e = \(Number\(cell\.e\) \|\| 0\) \+ eff/)       // 同一笔记一笔有效消耗
   assert.match(host, /var dk = localDayKey\(\)/)                           // 键取结算时刻本地日
   // 本地日口径：localDayKey 必须用本地 getters 拼（含 getFullYear/getMonth/getDate），不得用 toISOString
-  const dispatchSrc = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
-  const dkBody = dispatchSrc.match(/function localDayKey\(d\) \{[\s\S]{0,300}?\n    \}/)
-  assert.ok(dkBody, 'dispatch.mjs 应定义 localDayKey')
+  // （拆分第 7 刀 task-mvt8c1yx-7：localDayKey 随 accumulateRunUsage 搬至 lib/settle.mjs，断言随源码重指）
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
+  const dkBody = settleSrc.match(/function localDayKey\(d\) \{[\s\S]{0,300}?\n    \}/)
+  assert.ok(dkBody, 'settle.mjs 应定义 localDayKey')
   assert.match(dkBody[0], /getFullYear\(\)/)
   assert.match(dkBody[0], /getMonth\(\) \+ 1/)
   assert.match(dkBody[0], /getDate\(\)/)
@@ -3614,8 +3694,13 @@ const flush = () => new Promise(r => setImmediate(r))
 // 子进程探针源码（可续跑 Worker⑤ 用）：只在子进程里执行「真跑一次 continuable 派发 + 真读会话日志 + 真结算」。
 // 为什么必须子进程：findRunLog 走 os.homedir()（进程内首次调用即缓存），临时 HOME 只有在进程启动前
 // 设好才生效——同进程改 env 既无效又会带偏其它用例与真实看板目录。
+// CWD 解耦（task-mvr44r4m）：探针源码是字符串模板，其相对导入按子进程 CWD 解析——从仓库根跑会 ERR_MODULE_NOT_FOUND。
+// 修法：在本测试文件用 import.meta.url 换算出包内 lib 的 file:// 绝对 URL（Windows 下 ESM import 拒收裸盘符路径），
+// 注入探针源码头部的占位符，子进程 env/CWD 怎么变都不受影响。
+const PROBE_LIB_DISPATCH = new URL('../lib/dispatch.mjs', import.meta.url).href
+const PROBE_REPO_ROOT = fileURLToPath(new URL('../../..', import.meta.url)).replace(/[\\/]+$/, '') // git 仓库根（包外三层），钉 cwd 锁死回归
 const PROBE_CONTINUABLE_SOURCE = `
-const { createDispatch } = await import('./lib/dispatch.mjs')
+const { createDispatch } = await import(${JSON.stringify(PROBE_LIB_DISPATCH)})
 const SID = 'session-test-0000-0000-000000000000'
 const listeners = []
 const runs = {}
@@ -3667,8 +3752,11 @@ test('可续跑 Worker①：worker 走 startContinuable（rec 持 childId），v
   // verifier 的 rec 仍是旧形态（有 run、无 continuable）
   assert.equal(h.runs['v1'].continuable, undefined)
   assert.equal(String(h.runs['v1'].id), 'run-1')
-  // 订阅已注册且事件名正确（回退开关不影响的公共通道）
-  assert.deepEqual(h.listeners.map(l => l.name), ['agent/status'])
+  // 订阅已注册且事件名正确（回退开关不影响的公共通道）；挂死检测 v2 起帧活性订阅一并建立——
+  // 两种订阅都在位即可，顺序不断言死（防未来再加订阅又炸）
+  const names = h.listeners.map(l => l.name)
+  assert.ok(names.includes('agent/status'), 'agent/status 订阅在位')
+  assert.ok(names.includes('agent/assistant-stream'), 'agent/assistant-stream 订阅在位（帧活性）')
 })
 
 test('可续跑 Worker②：agent/status running→idle → settle 推进任务（真跑事件回调，非源码断言）', async () => {
@@ -3778,7 +3866,8 @@ test('可续跑 Worker⑤：idle 后从子会话 v4 日志读到助手文本 →
   fs.mkdirSync(path.join(tmp, '.dsh', 'sessions', 'b1', 'child-ok'), { recursive: true })
   fs.writeFileSync(path.join(tmp, '.dsh', 'sessions', 'b1', 'child-ok', 'session.v4.jsonl.zstd'), Buffer.concat(chunks))
   try {
-    const child = spawnSync(process.execPath, ['-e', PROBE_CONTINUABLE_SOURCE], { env: Object.assign({}, process.env, { HOME: tmp, USERPROFILE: tmp }), encoding: 'utf8' })
+    // cwd 显式钉到仓库根（PROBE_REPO_ROOT）：锁死「仓库根 CWD 跑探针」回归——import 已绝对锚定，CWD 不再影响解析。
+    const child = spawnSync(process.execPath, ['-e', PROBE_CONTINUABLE_SOURCE], { cwd: PROBE_REPO_ROOT, env: Object.assign({}, process.env, { HOME: tmp, USERPROFILE: tmp }), encoding: 'utf8' })
     assert.equal(child.status, 0, 'probe 失败: ' + child.stderr)
     const out = JSON.parse(child.stdout.trim().split('\n').pop())
     assert.equal(out.status, 'verifying')                 // 文本通道：有助手文本 → 正常推进 verifying
@@ -3790,28 +3879,29 @@ test('可续跑 Worker⑤：idle 后从子会话 v4 日志读到助手文本 →
 
 test('可续跑 Worker 接线（源码级）：事件订阅走 ctx.effect 回收 + 硬超时 interrupt 留存 + 重派续跑接线', () => {
   const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
   const rpcSrc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
   // ① 双路 spawn：Worker+开关开才走 startContinuable（verifier/hook 不受影响）
   assert.match(dsp, /var useContinuable = role === 'worker' && c\.workerContinuable !== false/)
   assert.match(dsp, /var cs = await subagents\.startContinuable\(\{ provider: providerName, label: req\.label, request: req, signal: req\.signal \}\)/)
   // ② 结算观测：agent/status 订阅 + running→idle + rec.ran 二次守卫 + effect 回收
-  assert.match(dsp, /ctx\.effect\(function \(\) \{ return ctx\.on\('agent\/status', onAgentStatus\) \}\)/)
-  assert.match(dsp, /if \(status !== 'idle' && status !== 'running'\) return/) // running 事件必须放行（rec.ran 的唯一来源）
-  assert.match(dsp, /if \(status === 'running'\) \{ rec\.ran = true; return \}/)
-  assert.match(dsp, /if \(!rec\.ran \|\| rec\.settled\) return/)
-  assert.match(dsp, /await settleRun\(sid, rec, \{ output: \[\{ type: 'text', text: text \}\], stopReason: text\.trim\(\) \? 'completed' : 'error' \}, null\)/)
+  assert.match(dsp, /ctx\.effect\(function \(\) \{ return ctx\.on\('agent\/status', settle\.onAgentStatus\) \}\)/)
+  assert.match(settleSrc, /if \(status !== 'idle' && status !== 'running'\) return/) // running 事件必须放行（rec.ran 的唯一来源）
+  assert.match(settleSrc, /if \(status === 'running'\) \{ rec\.ran = true; return \}/)
+  assert.match(settleSrc, /if \(!rec\.ran \|\| rec\.settled\) return/)
+  assert.match(settleSrc, /await settleRun\(sid, rec, \{ output: \[\{ type: 'text', text: text \}\], stopReason: text\.trim\(\) \? 'completed' : 'error' \}, null\)/)
   // ③ 卡2 Step1：硬超时/失败结算对 continuable 子会话改 interrupt（留存不销毁），一次性仍 dispose；
   //    authority 形状取 dsh-subagent 的 SubagentInterruptAuthority，interrupt 异常被吞进 resumeBlocked 不阻断结算。
-  assert.match(dsp, /async function endContinuable\(sid, rec\) \{/)
-  assert.match(dsp, /subagents\.interrupt\(rec\.childId, \{ kind: 'ancestor', agent: parent \}\)/)
-  assert.match(dsp, /if \(rec\.continuable\) await endContinuable\(sid, rec\)\s*\n\s*else await rec\.run\.dispose\(\)/)
-  assert.match(dsp, /rec\.resumeBlocked = true/)
+  assert.match(settleSrc, /async function endContinuable\(sid, rec\) \{/)
+  assert.match(settleSrc, /subagents\.interrupt\(rec\.childId, \{ kind: 'ancestor', agent: parent \}\)/)
+  assert.match(settleSrc, /if \(rec\.continuable\) await endContinuable\(sid, rec\)\s*\n\s*else await rec\.run\.dispose\(\)/)
+  assert.match(settleSrc, /rec\.resumeBlocked = true/)
   assert.match(dsp, /withTimeout\(abortableP, hardMs, rec\.role \+ ':' \+ t\.id\)/)
   // ④ 文本兜底复用 usage.mjs 现成读取器（与 agent-activity 同一套日志定位/分帧）+ 续跑基线（只认本轮新写字节）
-  assert.match(dsp, /var log = findRunLog\(childId, sessionsRoot\)/)
-  assert.match(dsp, /var buf = readLogBytes\(log, tail\)/)
-  assert.match(dsp, /childSessionOutput\(rec\.childId, rec\.baselineBytes\)/)
+  assert.match(settleSrc, /var log = findRunLog\(childId, sessionsRoot\)/)
+  assert.match(settleSrc, /var buf = readLogBytes\(log, tail\)/)
+  assert.match(settleSrc, /childSessionOutput\(rec\.childId, rec\.baselineBytes\)/)
   assert.match(dsp, /baselineBytes: logSizeOf\(childId\)/)
   // ⑤ 卡2 Step2/Step3：重派续跑接线（sendMessage 冷复活 + 薄框架断点续跑指令 + runs[] 续跑记录 +
   //    失败回退 fresh spawn）+ 三连败计数不受续跑影响（续跑同样走 settleWorker 的 retryCount 口径）
@@ -4037,11 +4127,12 @@ test('可续跑 Worker⑪（卡2⑤）：workerContinuable=false → 续跑机
 
 // 子进程探针（卡2 续跑基线护栏）：真建 v4 日志 → 真续跑 → 区分「续跑轮没产出（旧文本不得冒充交付物）」
 // 与「续跑轮真产出（正常推进 verifying）」。必须子进程：findRunLog 走 os.homedir() 且进程内首次调用即缓存。
+// CWD 解耦（task-mvr44r4m）：相对导入改为头部注入的 PROBE_LIB_DISPATCH file:// 绝对 URL（import.meta.url 换算），与 CWD 无关。
 const PROBE_RESUME_BASELINE_SOURCE = `
 const fs = await import('node:fs')
 const path = await import('node:path')
 const zlib = await import('node:zlib')
-const { createDispatch } = await import('./lib/dispatch.mjs')
+const { createDispatch } = await import(${JSON.stringify(PROBE_LIB_DISPATCH)})
 const SID = 'session-test-0000-0000-000000000000'
 const childId = 'child-old'
 const logDir = path.join(process.env.HOME, '.dsh', 'sessions', 'b1', childId)
@@ -4089,7 +4180,8 @@ console.log(JSON.stringify({ stale: stale, ok: { status: t.status, deliverable:
 test('可续跑 Worker⑫（卡2 续跑基线）：续跑轮没产出 → 残留旧文本不得冒充交付物（按失败重排）；真产出 → 正常推进 verifying', async () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'tbc2-'))
   try {
-    const child = spawnSync(process.execPath, ['-e', PROBE_RESUME_BASELINE_SOURCE], { env: Object.assign({}, process.env, { HOME: tmp, USERPROFILE: tmp }), encoding: 'utf8' })
+    // cwd 显式钉到仓库根（PROBE_REPO_ROOT）：锁死「仓库根 CWD 跑探针」回归——import 已绝对锚定，CWD 不再影响解析。
+    const child = spawnSync(process.execPath, ['-e', PROBE_RESUME_BASELINE_SOURCE], { cwd: PROBE_REPO_ROOT, env: Object.assign({}, process.env, { HOME: tmp, USERPROFILE: tmp }), encoding: 'utf8' })
     assert.equal(child.status, 0, 'probe 失败: ' + child.stderr)
     const out = JSON.parse(child.stdout.trim().split('\n').pop())
     assert.deepEqual(out.sent, ['child-old', 'child-old'])   // 两轮都是真续跑（sendMessage 冷复活）
@@ -4130,12 +4222,13 @@ test('可续跑 Worker⑬（卡2 手动终止臂）：终止 continuable run →
 
 test('hooks 接线（源码级）：spawnOneShot 三态 prompt + settleRun 分派 + pre/post 占用与 spawn 失败回收', () => {
   const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   // spawnOneShot：hook 角色走 buildHookPrompt（phase 由 role 决定）
   assert.match(dsp, /if \(role === 'hook-pre' \|\| role === 'hook-post'\) \{/)
   assert.match(dsp, /buildHookPrompt\(t, role === 'hook-pre' \? 'pre' : 'post', kids\)/)
-  // settleRun：hook 分支进 settleHook（照 worker/verifier 结算模式）
-  assert.match(dsp, /else if \(rec\.role === 'hook-pre' \|\| rec\.role === 'hook-post'\) await settleHook\(sid, rec, output, failed, errText\)/)
-  assert.match(dsp, /applyHookSettle\(d, rec\.taskId, phase, !\(failed \|\| esc\), output, runId, errText\)/)
+  // settleRun：hook 分支模块内直调 settleHook（拆分第 6 刀撤 roles 懒注入；照 worker/verifier 结算模式）
+  assert.match(settleSrc, /else if \(rec\.role === 'hook-pre' \|\| rec\.role === 'hook-post'\) await settleHook\(sid, rec, output, failed, errText\)/)
+  assert.match(settleSrc, /applyHookSettle\(d, rec\.taskId, phase, !\(failed \|\| esc\), output, runId, errText\)/) // 持锁段随源码重指 settle 源
   // pre 闸门占用（state=running 即幂等占用）与 post 补 spawn（pending 标记驱动，复用 verifierRun 幂等位）
   assert.match(dsp, /if \(hookOn\(t, 'pre'\) && t\.hooks\.pre\.state === 'idle' && !runs\[t\.id\]\) \{/)
   assert.match(dsp, /hookSetState\(t, 'pre', 'running', 'system', '派发前置 hook run'\)/)
@@ -4180,11 +4273,12 @@ test('史诗语义层接线：poolCycle 派发分支触发父卡流转 + get-tas
   // 两模块都从 core 解构引入（接线不断）；rpc.mjs 解构表尾部随调研门禁（task-mute6zpw）、调研遵循三件套（task-mutnj3a4）、
   // tasksHash（task-mutrtwin）、hooks 浅校验（normalizeHooks/mergeHooks，本批 hooks=agent run）、
   // 自测指南归一（normalizeUserTest，task-muxyyvg0）扩展；
-  // dispatch.mjs 解构表尾部追加 hook 族（buildHookPrompt/hookOn/hookSetState/gsb）与驳回包 helper（pushRejection，task-muvg15p5）、
+  // dispatch.mjs 解构表尾部追加 hook 族（buildHookPrompt/hookOn/hookSetState/gsb）、
   // depsSatisfied（task-mv9yupm4，spawn 落闸锁内补验依赖）、
   // Verifier 验收员加餐常量（VERIFIER_PERSONA/VERIFIER_TOOL_FILTER，task-muy3gm03）、
-  // 人工/外部操作留痕单行摘要（opsLogLine，task-mvnf3gly，Team 注入段「最近人工/外部操作」小节）
-  assert.match(host, /parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER, opsLogLine \} = core/)
+  // 人工/外部操作留痕单行摘要（opsLogLine，task-mvnf3gly，Team 注入段「最近人工/外部操作」小节）；
+  // 拆分第 6 刀（task-mvt8c1yx-6）：applyHookSettle/pushRejection 随角色结算搬至 settle.mjs 解构（本表不再持有）
+  assert.match(host, /parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, hookOn, hookSetState, gsb, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER, opsLogLine \} = core/)
   // rpc.mjs 解构表尾部再随建卡派发预警（appendDispatchWarning，task-mvbealtf）、力度路由档位表（TASK_SIZES，task-mvnemvf5）、
   // 人工/外部操作留痕单行摘要（opsLogLine，task-mvnf3gly，task_list recentOps 透出）扩展
   assert.match(host, /boardHome, aggregateChildStats, createTaskWarnings, epicPrecheck, epicPrecheckNote, attachContextSuggestions, REJECT_REDISPATCH_HINT, tasksHash, normalizeHooks, mergeHooks, pushRejection, normalizeUserTest, draftLint, appendDispatchWarning, TASK_SIZES, opsLogLine \} = core/)
@@ -4200,7 +4294,7 @@ test('史诗语义层接线：poolCycle 派发分支触发父卡流转 + get-tas
 // 函数声明提升后被头部 var x = deps.x 赋值覆盖，是永不执行的死代码——改错地方不产生效果，挪赋值顺序即引爆）。
 // 此处断言六个函数的定义只存在于 notify.mjs，任何模块再长出副本即红。
 test('notify 单一来源：notifyTaskDone/flushReceipts/deliverEscalation 等函数定义只存在于 lib/notify.mjs', () => {
-  const names = ['deliverEscalation', 'notifyMainWindow', 'maybeNotify', 'notifyTaskDone', 'notifyDispatched', 'pushSysNote', 'flushReceipts']
+  const names = ['deliverEscalation', 'notifyMainWindow', 'maybeNotify', 'notifyTaskDone', 'notifyDispatched', 'notifyDecomposed', 'pushSysNote', 'flushReceipts']
   const others = ['../index.mjs', '../lib/policy.mjs', '../lib/usage.mjs', '../lib/session.mjs', '../lib/store.mjs', '../lib/dispatch.mjs', '../lib/rpc.mjs']
   const notifySrc = readFileSync(new URL('../lib/notify.mjs', import.meta.url), 'utf8')
   for (const name of names) {
@@ -4300,6 +4394,167 @@ test('派发回执④：deps 未注入 notifyDispatched（老 host）→ 静默
   assert.equal(h.state.receiptBuf.s1.items.length, 1)
 })
 
+// ===== 拆解官回执（task-mvrqiu6x）：notifyDecomposed 入 45s 聚合队列「🧩 已拆解」分区 =====
+test('拆解回执①：notifyDecomposed 入队（kind=decomposed）→ flush 出「🧩 已拆解」分区（split/keep 文案）', async () => {
+  const h = mkNotify({ board: { tasks: [mkTask({ id: 'src1', title: '需求卡', status: 'draft' })] } })
+  h.notify.notifyDecomposed('s1', { sourceId: 'src1', sourceTitle: '需求卡', verdict: 'split', children: [{ id: 'src1-1', title: '子卡A' }, { id: 'src1-2', title: '子卡B' }], reason: '' })
+  const buf = h.state.receiptBuf.s1
+  assert.equal(buf.items.length, 1)
+  assert.equal(buf.items[0].kind, 'decomposed')
+  assert.equal(buf.items[0].id, 'src1')
+  pushFour(h)
+  await new Promise(r => setImmediate(r))
+  assert.equal(h.captured.length, 1)
+  const txt = textOf(h.captured[0])
+  assert.match(txt, /🧩 已拆解 1 个（待确认发布）：/)
+  assert.match(txt, /需求卡 \(src1\) — split：2 张子卡（子卡A、子卡B）/)
+  assert.equal(h.captured[0].source.kind, 'plugin:dsh-agent-board')
+  // keep 判定：同分区「无需拆分」文案（断言③）
+  const h2 = mkNotify({ board: { tasks: [mkTask({ id: 'src2', title: '无需拆卡', status: 'draft' })] } })
+  h2.notify.notifyDecomposed('s1', { sourceId: 'src2', sourceTitle: '无需拆卡', verdict: 'keep', children: [], reason: '结构单一' })
+  pushFour(h2)
+  await new Promise(r => setImmediate(r))
+  const txt2 = textOf(h2.captured[0])
+  assert.match(txt2, /🧩 已拆解 1 个（待确认发布）：/)
+  assert.match(txt2, /无需拆卡 \(src2\) — keep：无需拆分/)
+})
+
+test('拆解回执②：源卡停 draft/pending（非 in-progress）→ decomposed 回执不被投递过滤器丢弃（关键回归）', async () => {
+  // 源卡 draft/pending 是设计常态——正是原实现绕行系统通道借 pushSysNote 的原因；
+  // 此处把 deliver 投递过滤器的「decomposed 豁免」钉死，防后人把「非 in-progress 丢弃」改成通用规则误伤
+  for (const st of ['draft', 'pending']) {
+    const h = mkNotify({ board: { tasks: [mkTask({ id: 'src9', title: '需求卡', status: st })] } })
+    h.notify.notifyDecomposed('s1', { sourceId: 'src9', sourceTitle: '需求卡', verdict: 'split', children: [{ id: 'src9-1', title: '子卡X' }], reason: '' })
+    pushFour(h)
+    await new Promise(r => setImmediate(r))
+    assert.equal(h.captured.length, 1, st + ' 状态消息应投递')
+    const txt = textOf(h.captured[0])
+    assert.match(txt, /🧩 已拆解 1 个（待确认发布）：/, st + ' 拆解回执不得被「任务非 in-progress」过滤器丢弃')
+    assert.match(txt, /需求卡 \(src9\) — split：1 张子卡（子卡X）/)
+  }
+})
+
+test('拆解回执⑥：源卡已 archived → decomposed 回执被丢弃（人已手动归档=已知悉）', async () => {
+  const h = mkNotify({ board: { tasks: [mkTask({ id: 'srcA', title: '已归档卡', status: 'archived' })] } })
+  h.notify.notifyDecomposed('s1', { sourceId: 'srcA', sourceTitle: '已归档卡', verdict: 'split', children: [{ id: 'srcA-1', title: '子卡Y' }], reason: '' })
+  assert.equal(h.state.receiptBuf.s1.items.length, 1) // 入队照常，flush 时投递前过滤
+  pushFour(h)
+  await new Promise(r => setImmediate(r))
+  assert.equal(h.captured.length, 1)
+  const txt = textOf(h.captured[0])
+  assert.doesNotMatch(txt, /🧩 已拆解/)   // 源卡已 archived → 拆解回执被吞（唯一离场规则）
+  assert.match(txt, /✅ 完成 4 个：/)      // 完成回执（主通道）照常投递
+})
+
+test('拆解回执⑦：同一批重复上报 → 幂等零重复；换一批子卡/verdict → 指纹不同正常新回执', () => {
+  const h = mkNotify({ board: { tasks: [] } })
+  const payload = { sourceId: 'srcI', sourceTitle: '幂等卡', verdict: 'split', children: [{ id: 'srcI-1', title: 'A' }, { id: 'srcI-2', title: 'B' }] }
+  h.notify.notifyDecomposed('s1', payload)
+  h.notify.notifyDecomposed('s1', payload) // 同一批提案重复上报 → 幂等键（源卡id|verdict|子卡id集）一致 → 吞掉
+  assert.equal(h.state.receiptBuf.s1.items.length, 1)
+  h.notify.notifyDecomposed('s1', Object.assign({}, payload, { children: [{ id: 'srcI-3', title: 'C' }] })) // 换一批子卡
+  assert.equal(h.state.receiptBuf.s1.items.length, 2)
+  h.notify.notifyDecomposed('s1', { sourceId: 'srcI', sourceTitle: '幂等卡', verdict: 'keep', children: [] }) // verdict 变 → 新指纹
+  assert.equal(h.state.receiptBuf.s1.items.length, 3)
+})
+
+// 拆解官结算分支 harness（task-mvrqiu6x）：decomposer 一次性 run 以给定结果落定 → settleDecompose 三分支。
+// 与 runVerifierFuseCase 同构：createDispatch 直调 + mock subagents.start（run.result 由用例给定）+
+// pushSysNote/notifyDecomposed 捕获；源卡 draft（设计常态），spawnOneShot 直调（拆解官由 task_decompose 派生）。
+async function runDecomposeCase(opts) {
+  const o = opts || {}
+  const t = mkTask({ id: 'dec-src', title: '待拆解源卡', status: 'draft' })
+  const board = mkBoard([t])
+  if (o.notifyDone === false) board.notifyDone = false
+  const notes = []
+  const deco = []
+  const runs = {}
+  const listeners = []
+  const ctx = {
+    fs: {}, get: function () { return null }, timer: null,
+    effect: function (f) { var d = f(); return function () { if (typeof d === 'function') d() } },
+    on: function (name, fn) { listeners.push({ name: name, fn: fn }); return function () {} },
+    subagents: {
+      list: () => ['mock'],
+      getProvider: () => ({ inheritsParentContext: false }),
+      // spawn 本身成功；run.result 由用例给定（structured 分支 / 纯文本 / 失败）
+      start: async () => ({ id: 'run-dec', result: o.result, dispose: async function () {} }),
+      startContinuable: async () => ({ childId: 'child-x', messageId: 'm1' }),
+    },
+  }
+  const dispatch = createDispatch(ctx, { knownSessions: {}, dispatchedEver: {}, badModels: {}, teamModeCache: {}, activeRuns: { [FULL_SID]: runs } }, {
+    rt: async () => board, wt: async () => {}, mutateLocked: async (sid, fn) => fn(board), kickCycle: () => {},
+    rootForSession: () => ({ id: FULL_SID }),
+    withTimeout: (p) => p, runsFor: () => runs, feedbackOn: () => true,
+    pushSysNote: (sid, text) => { notes.push(text) }, maybeNotify: () => {}, notifyTaskDone: () => {},
+    notifyDecomposed: (sid, payload) => { deco.push(payload) },
+  })
+  const rec = await dispatch.spawnOneShot(FULL_SID, board.tasks[0], 'decomposer')
+  assert.ok(rec, 'decomposer spawn 应成功（源卡 draft）')
+  const flushN = () => new Promise(r => setImmediate(r))
+  for (var i = 0; i < 8; i++) await flushN()
+  return { notes: notes, deco: deco, board: board }
+}
+
+test('拆解回执④split：settleDecompose split 成功 → notifyDecomposed 正式回执（不再伪装 ⚠️ 系统异常）', async () => {
+  const r = await runDecomposeCase({ result: Promise.resolve({ output: [{ type: 'text', text: '' }], stopReason: 'completed', structured: { verdict: 'split', children: [{ title: '子卡A', size: 'light', touches: [], acceptance: 'x' }] } }) })
+  assert.equal(r.deco.length, 1, 'split 成功应发拆解回执')
+  assert.equal(r.deco[0].sourceId, 'dec-src')
+  assert.equal(r.deco[0].sourceTitle, '待拆解源卡')
+  assert.equal(r.deco[0].verdict, 'split')
+  assert.equal(r.deco[0].children.length, 1)
+  assert.equal(r.deco[0].children[0].id, 'dec-src-1') // decomposeChildId：parentId-N
+  assert.equal(r.notes.length, 0, '成功信号不得再借 pushSysNote 伪装成 ⚠️ 系统异常')
+  const t = r.board.tasks.find(x => x.id === 'dec-src')
+  assert.equal(t.status, 'draft', '源卡状态不变')
+  assert.ok(t.messages.some(m => /🧩 拆解提案已就位/.test(m.text)), '源卡 messages 留痕照旧')
+})
+
+test('拆解回执③keep：settleDecompose keep → 同分区「无需拆分」回执（不落系统异常）', async () => {
+  const r = await runDecomposeCase({ result: Promise.resolve({ output: [{ type: 'text', text: '' }], stopReason: 'completed', structured: { verdict: 'keep', rationale: '结构单一' } }) })
+  assert.equal(r.deco.length, 1, 'keep 应发拆解回执')
+  assert.equal(r.deco[0].sourceId, 'dec-src')
+  assert.equal(r.deco[0].verdict, 'keep')
+  assert.equal(r.deco[0].reason, '结构单一')
+  assert.equal(r.notes.length, 0, 'keep 成功也不落 ⚠️ 系统异常')
+  const t2 = r.board.tasks.find(x => x.id === 'dec-src')
+  assert.ok(t2.messages.some(m => /🧩 拆解官判定无需拆分/.test(m.text)), 'rationale 落源卡消息照旧')
+})
+
+test('拆解回执④失败：run 失败/structured 缺失 → 仍落「⚠️ 系统异常」区且不产生 decomposed 回执', async () => {
+  const r1 = await runDecomposeCase({ result: Promise.reject(new Error('provider timeout')) })
+  assert.equal(r1.deco.length, 0, 'run 失败不产生拆解回执')
+  assert.equal(r1.notes.length, 1)
+  assert.match(r1.notes[0], /🚨 拆解官 run 未产出可用提案（源卡 dec-src）/, '失败分支保持 🚨 系统通道逐字不变')
+  const t1 = r1.board.tasks.find(x => x.id === 'dec-src')
+  assert.ok(t1.messages.some(m => /🧩 拆解官 run 失败/.test(m.text)), '失败原因落源卡消息照旧')
+
+  const r2 = await runDecomposeCase({ result: Promise.resolve({ output: [{ type: 'text', text: '自由文本' }], stopReason: 'completed' }) })
+  assert.equal(r2.deco.length, 0, 'structured 缺失不产生拆解回执')
+  assert.equal(r2.notes.length, 1)
+  assert.match(r2.notes[0], /🚨 拆解官 run 未产出可用提案/, 'structured 缺失走同一 🚨 失败臂')
+})
+
+test('拆解回执⑤：notifyDone=false → 拆解回执不入队；源卡 messages 留痕照旧不丢', async () => {
+  const r = await runDecomposeCase({ notifyDone: false, result: Promise.resolve({ output: [{ type: 'text', text: '' }], stopReason: 'completed', structured: { verdict: 'split', children: [{ title: '子卡A', size: 'light', touches: [], acceptance: 'x' }] } }) })
+  assert.equal(r.deco.length, 0, '完成回执开关关 → 拆解回执不入队')
+  assert.equal(r.notes.length, 0, '开关只闸回执，成功路径也不再落系统异常')
+  const t3 = r.board.tasks.find(x => x.id === 'dec-src')
+  assert.ok(t3.messages.some(m => /🧩 拆解提案已就位/.test(m.text)), '关开关时源卡 messages 留痕照旧不丢')
+  const r2 = await runDecomposeCase({ notifyDone: false, result: Promise.reject(new Error('boom')) })
+  assert.equal(r2.notes.length, 1, '失败分支不受 notifyDone 影响（异常就该是异常）')
+})
+
+test('拆解回执⑧：settleDecompose 三分支与 index 接线在位（源面断言，防接线回退）', () => {
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8') // 拆分第 6 刀：settleDecompose 随源码重指 settle 源
+  // split/keep 成功走 notifyDecomposed（notifyDone 闸门 + 老 host 未注入静默），失败分支保持 🚨 pushSysNote
+  assert.match(settleSrc, /if \(doneOn && typeof notifyDecomposed === 'function'\) notifyDecomposed\(sid, \{ sourceId: rec\.taskId, sourceTitle: srcTitle, verdict: 'split'/)
+  assert.match(settleSrc, /if \(doneOn && typeof notifyDecomposed === 'function'\) notifyDecomposed\(sid, \{ sourceId: rec\.taskId, sourceTitle: srcTitle, verdict: 'keep'/)
+  assert.match(settleSrc, /else pushSysNote\(sid, '🚨 拆解官 run 未产出可用提案（源卡 ' \+ rec\.taskId \+ '）：'/)
+  const idx = readFileSync(new URL('../index.mjs', import.meta.url), 'utf8')
+  assert.match(idx, /notifyDecomposed: notify\.notifyDecomposed/) // index.mjs 接线在位
+})
+
 // ===== 回执开关进设置（task-muuwgcro）：板级 notifyDispatch/notifyDone 双布尔（缺省 true）+ 两处闸门 =====
 // 用户指令：「回执可以做一个开关，放到设置里」。语义：设置区「通知」小节可分别关掉「派发回执」与
 // 「完成回执」；歧义裁决通知（notifyMainWindow）是裁决通道不是回执，不接入开关。
@@ -4388,16 +4643,17 @@ test('回执开关③b：notifyDone=false → worker 三连败转 blocked 也不
 })
 
 test('回执开关③/④：完成/阻塞回执闸门在结算调用方；歧义裁决通道零开关（源码级断言）', () => {
-  const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8') // 拆分第 6 刀：四个结算函数随源码重指 settle 源
   const noti = readFileSync(new URL('../lib/notify.mjs', import.meta.url), 'utf8')
-  // 完成回执：三个结算函数（worker/verifier/hook）都在同一次持锁回调里取 notifyDone（零额外读盘）
-  assert.equal((dsp.match(/doneOn = cfg\(d\)\.notifyDone !== false/g) || []).length, 3)
-  assert.equal((dsp.match(/if \(doneOn && /g) || []).length, 5) // worker 2 + verifier 2 + hook-closed 1
-  assert.match(dsp, /if \(doneOn && result\.task && result\.task\.status === 'resolved'\) notifyTaskDone\(sid, result\.task, 'resolved'\)/)
-  assert.match(dsp, /if \(doneOn && result\.task && result\.task\.status === 'blocked'\) notifyTaskDone\(sid, result\.task, 'blocked'\)/)
-  assert.match(dsp, /if \(result\.blocked\) \{ maybeNotify\(sid, result\.task\); if \(doneOn\) notifyTaskDone\(sid, result\.task, 'blocked'\) \}/)
+  // 完成回执：四个结算函数（worker/verifier/hook + 拆解官 decompose，task-mvrqiu6x 起后者也受 notifyDone 约束）
+  // 都在同一次持锁回调里取 notifyDone（零额外读盘）
+  assert.equal((settleSrc.match(/doneOn = cfg\(d\)\.notifyDone !== false/g) || []).length, 4)
+  assert.equal((settleSrc.match(/if \(doneOn && /g) || []).length, 7) // worker 2 + verifier 2 + hook-closed 1 + decompose split/keep 2
+  assert.match(settleSrc, /if \(doneOn && result\.task && result\.task\.status === 'resolved'\) notifyTaskDone\(sid, result\.task, 'resolved'\)/)
+  assert.match(settleSrc, /if \(doneOn && result\.task && result\.task\.status === 'blocked'\) notifyTaskDone\(sid, result\.task, 'blocked'\)/)
+  assert.match(settleSrc, /if \(result\.blocked\) \{ maybeNotify\(sid, result\.task\); if \(doneOn\) notifyTaskDone\(sid, result\.task, 'blocked'\) \}/)
   // 闸门默认 true：回调未跑到也不漏报（宁可多报）
-  assert.equal((dsp.match(/var doneOn = true/g) || []).length, 3)
+  assert.equal((settleSrc.match(/var doneOn = true/g) || []).length, 4) // worker/verifier/hook 各一 + settleDecompose 一
   // ④ 歧义通道零开关：通知层根本读不到板级配置（cfg 未引入），去注释后的上报代码段不含两个开关名
   assert.doesNotMatch(noti, /cfg\(/)
   const escBlock = noti.slice(noti.indexOf('// 歧义上报通知'), noti.indexOf('// ===== 任务回执通知'))
@@ -4405,7 +4661,7 @@ test('回执开关③/④：完成/阻塞回执闸门在结算调用方；歧义
   const escCode = escBlock.split('\n').filter(l => !/^\s*\/\//.test(l)).join('\n')
   assert.doesNotMatch(escCode, /notifyDispatch|notifyDone/)
   // 三个结算点的歧义通知调用（maybeNotify）都不带任何开关闸门
-  assert.equal((dsp.match(/maybeNotify\(sid, result\.task\)/g) || []).length, 3)
+  assert.equal((settleSrc.match(/maybeNotify\(sid, result\.task\)/g) || []).length, 3)
 })
 
 test('回执开关⑤：设置弹层「通知」小节两行开关 + set-board-config 读写通道（源码 + RPC 行为）', async () => {
@@ -5663,22 +5919,28 @@ test('僵尸 run 留档清扫：落定卡 running 无 endedAt 留档被关账+
 
 test('僵尸 run 留档清扫接线（源码级）：sweepZombieRuns 定义 + poolCycle 挂点 + 只清扫落定卡门禁', () => {
   const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  // 拆分第 7 刀（task-mvt8c1yx-7，仲裁扩权放行）：sweepZombieRuns 随源码搬至 lib/settle.mjs
+  // ——函数体机制锁断言随源码重指 settle 源；poolCycle 挂点接线断言仍锁 dispatch 源（挂点改 settle.* 形态）。
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   // ① 清扫函数定义（含「只对落定卡做」状态门禁与「无活跃 rec 才扫」护栏）
-  assert.match(dsp, /async function sweepZombieRuns\(sid, snap\) \{/)
-  assert.match(dsp, /if \(t\.status !== 'resolved' && t\.status !== 'cancelled' && t\.status !== 'archived'\) return/)
-  assert.match(dsp, /if \(rec && !rec\.settled && String\(rec\.id\) === rid\) return/)
-  assert.match(dsp, /r\.outcome = 'stale-closed'/)
-  assert.match(dsp, /r\.endedAt = new Date\(\)\.toISOString\(\)/)
-  assert.match(dsp, /r\.note = 'host 重启僵尸留档清扫'/)
-  assert.match(dsp, /if \(t\.verifierRun === rid\) \{ t\.verifierRun = null; delete t\.verifierRunAt \}/)
-  assert.match(dsp, /if \(t\.claimedBy === rid\) \{ t\.claimedBy = null; t\.claimedAt = null \}/)
-  assert.match(dsp, /return any \? d : null/) // 无改动不写盘（安静板不因清扫产生心跳写盘）
+  assert.match(settleSrc, /async function sweepZombieRuns\(sid, snap\) \{/)
+  assert.match(settleSrc, /if \(t\.status !== 'resolved' && t\.status !== 'cancelled' && t\.status !== 'archived'\) return/)
+  assert.match(settleSrc, /if \(rec && !rec\.settled && String\(rec\.id\) === rid\) return/)
+  assert.match(settleSrc, /r\.outcome = 'stale-closed'/)
+  assert.match(settleSrc, /r\.endedAt = new Date\(\)\.toISOString\(\)/)
+  assert.match(settleSrc, /r\.note = 'host 重启僵尸留档清扫'/)
+  assert.match(settleSrc, /if \(t\.verifierRun === rid\) \{ t\.verifierRun = null; delete t\.verifierRunAt \}/)
+  assert.match(settleSrc, /if \(t\.claimedBy === rid\) \{ t\.claimedBy = null; t\.claimedAt = null \}/)
+  assert.match(settleSrc, /return any \? d : null/) // 无改动不写盘（安静板不因清扫产生心跳写盘）
   // ② poolCycle 挂点：reconcile 之后、幽灵回收之前（落定卡僵尸留档 reconcile/reap 都管不到，须在空闲快进前兜到）
-  assert.match(dsp, /try \{ await sweepZombieRuns\(sid, snap\) \} catch \(e\) \{ console\.error\('\[task-board\] 僵尸留档清扫失败:/)
+  assert.match(dsp, /try \{ await settle\.sweepZombieRuns\(sid, snap\) \} catch \(e\) \{ console\.error\('\[task-board\] 僵尸留档清扫失败:/)
 })
 
 test('卡2/卡3 接线（源码级）：usage 水位线落卡 + reconcile 一次性 + 详情页 ↻ 续跑标注 + 文档收尾', () => {
   const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  // 拆分第 7 刀（task-mvt8c1yx-7，仲裁扩权放行）：usage 水位/accumulateRunUsage/reconcileRoot 随源码搬至
+  // lib/settle.mjs——②③机制锁断言随源码重指 settle 源；poolCycle 挂点接线断言仍锁 dispatch 源（settle.* 形态）。
+  const settleSrc = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   const usageSrc = readFileSync(new URL('../lib/usage.mjs', import.meta.url), 'utf8')
   const cli = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
   // ① usage 增量：readRunUsage 收第三参 sinceSeq，只认水位线之后的帧，并回传全份 maxSeq
@@ -5686,24 +5948,24 @@ test('卡2/卡3 接线（源码级）：usage 水位线落卡 + reconcile 一次
   assert.match(usageSrc, /if \(from > 0 && sq <= from\) continue/)
   assert.match(usageSrc, /maxSeq: -1/)
   // ② 结算侧：水位线从卡上 runs 条目读、增量累加后写回（只增不减）
-  assert.match(dsp, /function seekSeqOf\(snap, taskId, runId\) \{/)
-  assert.match(dsp, /since = seekSeqOf\(snap0, rec\.taskId, rec\.id\)/)
-  assert.match(dsp, /u = readRunUsage\(String\(rec\.id\), sessionsRoot, since\)/)
+  assert.match(settleSrc, /function seekSeqOf\(snap, taskId, runId\) \{/)
+  assert.match(settleSrc, /since = seekSeqOf\(snap0, rec\.taskId, rec\.id\)/)
+  assert.match(settleSrc, /u = readRunUsage\(String\(rec\.id\), sessionsRoot, since\)/)
   // 同 id 的续跑新条目尚未结算（usageSeq 未设）→ 必须继续往前找已结算的那条，否则水位线恒 0（踩过的坑）
-  assert.match(dsp, /if \(!r \|\| String\(r\.id\) !== String\(runId\)\) continue\s*\n\s*var w = num0\(r\.usageSeq\)\s*\n\s*if \(w > 0\) return w/)
-  assert.match(dsp, /t\.runs\[ri\]\.usageSeq = Math\.max\(num0\(t\.runs\[ri\]\.usageSeq\), num0\(u\.maxSeq\)\)/)
+  assert.match(settleSrc, /if \(!r \|\| String\(r\.id\) !== String\(runId\)\) continue\s*\n\s*var w = num0\(r\.usageSeq\)\s*\n\s*if \(w > 0\) return w/)
+  assert.match(settleSrc, /t\.runs\[ri\]\.usageSeq = Math\.max\(num0\(t\.runs\[ri\]\.usageSeq\), num0\(u\.maxSeq\)\)/)
   // ③ reconcile：per-host 一次性标记 + listChildren 存活判定 + 重建 rec/重挂超时臂 + 死会话回 pending
-  assert.match(dsp, /async function reconcileRoot\(sid\) \{/)
-  assert.match(dsp, /if \(state\.reconcileDone\[sid\]\) return/)
-  assert.match(dsp, /typeof subagents\.listChildren !== 'function'/)
-  assert.match(dsp, /await withTimeout\(q, 5000, 'reconcile listChildren'\)/)
-  assert.match(dsp, /restored: true, ran: false/)
-  assert.match(dsp, /baselineBytes: logSizeOf\(childId\)/)
-  assert.match(dsp, /armTimeouts\(sid, rec, tc, c2\)/)
-  assert.match(dsp, /last\.outcome = 'timeout\/error'; last\.endedAt = new Date\(\)\.toISOString\(\)/)
-  assert.match(dsp, /续跑观测已恢复/)
+  assert.match(settleSrc, /async function reconcileRoot\(sid\) \{/)
+  assert.match(settleSrc, /if \(state\.reconcileDone\[sid\]\) return/)
+  assert.match(settleSrc, /typeof subagents\.listChildren !== 'function'/)
+  assert.match(settleSrc, /await withTimeout\(q, 5000, 'reconcile listChildren'\)/)
+  assert.match(settleSrc, /restored: true, ran: false/)
+  assert.match(settleSrc, /baselineBytes: logSizeOf\(childId\)/)
+  assert.match(settleSrc, /armTimeouts\(sid, rec, tc, c2\)/)
+  assert.match(settleSrc, /last\.outcome = 'timeout\/error'; last\.endedAt = new Date\(\)\.toISOString\(\)/)
+  assert.match(settleSrc, /续跑观测已恢复/)
   // poolCycle 入口接线（在读 runs/snap 之前，重建的 rec 参与本轮活跃计数）
-  assert.match(dsp, /try \{ await reconcileRoot\(sid\) \} catch \(e\) \{ console\.error\('\[task-board\] reconcile 失败:'/)
+  assert.match(dsp, /try \{ await settle\.reconcileRoot\(sid\) \} catch \(e\) \{ console\.error\('\[task-board\] reconcile 失败:'/)
   // ④ 详情页 ↻ 续跑标注（读卡2 落的 runs[i].resume，不猜；老留档零渲染）
   assert.match(cli, /var rsMark = r\.resume === true \? ' ↻' : ''/)
   assert.match(cli, /↻ 冷复活续跑：沿用上一次的子会话，非新开/)
@@ -6027,7 +6289,7 @@ test('池冻结根修⑤（接线，源码级）：幽灵回收在活跃度计
   const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
   const sto = readFileSync(new URL('../lib/store.mjs', import.meta.url), 'utf8')
   // ① 回收必须在 activeW 计数与 pickDispatch 之前（否则本轮依旧被幽灵拖住）
-  const iReap = dsp.indexOf('reapedN = await reapGhostRecs(sid, snap)')
+  const iReap = dsp.indexOf('reapedN = await settle.reapGhostRecs(sid, snap)') // 拆分第 7 刀：挂点改经 settle 实例
   const iCount = dsp.indexOf('if (rc0.role === \'worker\') activeW++')
   assert.ok(iReap > 0 && iCount > iReap, '幽灵回收必须先于活跃度计数')
   // ② 回收后重读快照（否则空闲快进的 wt(snap) 会把收尾结果覆盖回旧状态）