dsh-agent-board 1.9.1 → 1.9.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agent-board",
   "description": "DeepSeek Harness 智能看板：任务卡片 + 一次性 Worker/Verifier 派发 + 依赖调度 + 管线分档 + Team 模式（歧义上报主窗口裁决）",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "type": "module",
   "main": "./index.mjs",
   "scripts": {

package/test/core.test.mjs

@@ -20,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 || {}) }
@@ -1085,6 +1086,38 @@ test('parsePlanFiles: 收紧——全角分隔长说明段不进清单；含路
   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)
@@ -2166,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'/)
@@ -2656,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（优雅降级，不抛错）', () => {
@@ -2725,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\(\)/)
@@ -3844,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 口径）
@@ -4186,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'\)/)
@@ -4236,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/)
@@ -4508,11 +4546,11 @@ test('拆解回执⑤：notifyDone=false → 拆解回执不入队；源卡 mess
 })
 
 test('拆解回执⑧：settleDecompose 三分支与 index 接线在位（源面断言，防接线回退）', () => {
-  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 刀：settleDecompose 随源码重指 settle 源
   // split/keep 成功走 notifyDecomposed（notifyDone 闸门 + 老 host 未注入静默），失败分支保持 🚨 pushSysNote
-  assert.match(dsp, /if \(doneOn && typeof notifyDecomposed === 'function'\) notifyDecomposed\(sid, \{ sourceId: rec\.taskId, sourceTitle: srcTitle, verdict: 'split'/)
-  assert.match(dsp, /if \(doneOn && typeof notifyDecomposed === 'function'\) notifyDecomposed\(sid, \{ sourceId: rec\.taskId, sourceTitle: srcTitle, verdict: 'keep'/)
-  assert.match(dsp, /else pushSysNote\(sid, '🚨 拆解官 run 未产出可用提案（源卡 ' \+ rec\.taskId \+ '）：'/)
+  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 接线在位
 })
@@ -4605,17 +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 + 拆解官 decompose，task-mvrqiu6x 起后者也受 notifyDone 约束）
   // 都在同一次持锁回调里取 notifyDone（零额外读盘）
-  assert.equal((dsp.match(/doneOn = cfg\(d\)\.notifyDone !== false/g) || []).length, 4)
-  assert.equal((dsp.match(/if \(doneOn && /g) || []).length, 7) // worker 2 + verifier 2 + hook-closed 1 + decompose split/keep 2
-  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'\) \}/)
+  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, 4) // worker/verifier/hook 各一 + settleDecompose 一
+  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('// ===== 任务回执通知'))
@@ -4623,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 () => {
@@ -5881,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
@@ -5904,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, /↻ 冷复活续跑：沿用上一次的子会话，非新开/)
@@ -6245,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) 会把收尾结果覆盖回旧状态）

package/test/fault-injection-docs.test.mjs

@@ -11,16 +11,19 @@
 //   ④ 测试分层纪律节——事故复盘双落纪律（单测断言锁机制 + fault-e2e-* 场景锁接缝）+
 //      新事故类加卡模板指向 fault-e2e-recovery.test.mjs；
 //   ⑤ 关键契约词全文在案——startActivation / listProviders / session.v4.jsonl.zstd /
-//      五档故障名（instant-kill/hang/empty/rate-limit/slow）+ 消费点行号锚；
+//      五档故障名（instant-kill/hang/empty/rate-limit/slow）+ 消费点「文件 + 符号」锚；
 //   ⑥ 文档与源码同口径——五档故障名逐一在 fault-provider.mjs FAULT_TYPES 常量里（源码真值），
-//      dispatch.mjs 消费点符号（hasActivationApi/activationAsRun/modelDirectory/probeModel）在案，
-//      文档行号锚不悬空。
+//      消费点符号在案（dispatch.mjs: hasActivationApi/activationAsRun/activationRequestOf；拆分后
+//      model-health.mjs: modelDirectory/probeModel），文档锚不悬空。
+//   ⑦ 行号锚清扫锁（task-mvt8c1yx-8 拆分第 8 刀）：拆分令行号持续漂移，文档一律按「文件 + 函数/
+//      符号名」定位——旧行号锚（L806-823/L163-178/L294-332）与任何 L<行号> 形式一律不得回潮。
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 
 const doc = readFileSync(new URL('../docs/fault-injection.md', import.meta.url), 'utf8')
 const dispatch = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+const modelHealth = readFileSync(new URL('../lib/model-health.mjs', import.meta.url), 'utf8')
 const faultProvider = readFileSync(new URL('./helpers/fault-provider.mjs', import.meta.url), 'utf8')
 
 test('①文档存在 + 三节锚点标题在案（A/B 权衡记录 / B 路径接缝契约 / 测试分层纪律）', () => {
@@ -89,16 +92,27 @@ test('④测试分层纪律节：事故复盘双落纪律 + 新事故类加卡
   ]) assert.ok(doc.includes(m), '测试分层纪律节缺锚点：' + m)
 })
 
-test('⑤关键契约词全文在案：五档故障名 + startActivation/listProviders/session.v4.jsonl.zstd + 行号锚', () => {
+test('⑤关键契约词全文在案：五档故障名 + startActivation/listProviders/session.v4.jsonl.zstd + 符号锚', () => {
   for (const n of ['instant-kill', 'hang', 'empty', 'rate-limit', 'slow']) {
     assert.ok(doc.includes(n), '文档缺五档故障名：' + n)
   }
   for (const m of ['startActivation', 'listProviders', 'session.v4.jsonl.zstd']) {
     assert.ok(doc.includes(m), '文档缺关键契约词：' + m)
   }
-  for (const m of ['L806-823', 'L163-178', 'L294-332']) {
-    assert.ok(doc.includes(m), '文档缺消费点行号锚：' + m)
+  // 消费点锚一律「文件 + 函数/符号名」口径（task-mvt8c1yx-8）：拆分后行号必漂，符号不漂。
+  for (const m of ['lib/dispatch.mjs', 'lib/model-health.mjs', 'spawnOneShot', 'hasActivationApi',
+    'activationAsRun', 'activationRequestOf', 'modelDirectory()', 'probeModel()']) {
+    assert.ok(doc.includes(m), '文档缺消费点符号锚：' + m)
   }
+  for (const dead of ['L806-823', 'L163-178', 'L294-332']) {
+    assert.ok(!doc.includes(dead), '文档残留旧行号锚（拆分后已漂移，按符号定位）：' + dead)
+  }
+  assert.ok(!/L\d{2,4}/.test(doc), '文档不得再出现 L<行号> 形式锚点（历次拆分会令其漂移）')
+})
+
+test('⑦行号锚清扫：lib/ 与 docs/ 不再有指向 dispatch.mjs 的 L<行号> 锚（预研清单语法说明除外）', () => {
+  assert.ok(!/dispatch\.mjs[^\n]*L\d/.test(doc), 'fault-injection.md 残留 dispatch.mjs 行号锚')
+  assert.ok(!/dispatch[^\n]*\s\d{3}\b/.test(doc), 'fault-injection.md 残留「dispatch <行号>」式锚')
 })
 
 test('⑥文档与源码同口径：五档在 FAULT_TYPES 常量里（源码真值）+ dispatch.mjs 消费点符号在案', () => {
@@ -107,8 +121,12 @@ test('⑥文档与源码同口径：五档在 FAULT_TYPES 常量里（源码真
   for (const n of ['instant-kill', 'hang', 'empty', 'rate-limit', 'slow']) {
     assert.ok(types[1].includes("'" + n + "'"), 'FAULT_TYPES 缺五档故障名：' + n)
   }
-  // 文档引用的行号锚不悬空：引用的符号在源码里逐一在案（符号级同口径）
-  for (const s of ['hasActivationApi', 'activationAsRun', 'activationRequestOf', 'modelDirectory', 'probeModel', 'startActivation']) {
+  // 文档引用的消费点符号不悬空（符号级同口径）：spawn/activation 面仍在 dispatch.mjs，
+  // 模型目录/探测面已拆至 lib/model-health.mjs（第 2/4 刀）——文档锚指到新文件，此处回源码复检。
+  for (const s of ['hasActivationApi', 'activationAsRun', 'activationRequestOf', 'startActivation']) {
     assert.ok(dispatch.includes(s), 'dispatch.mjs 缺消费点符号：' + s)
   }
+  for (const s of ['function modelDirectory', 'function probeModel']) {
+    assert.ok(modelHealth.includes(s), 'lib/model-health.mjs 缺消费点符号：' + s)
+  }
 })

package/test/lane-gui-bysize.test.mjs

@@ -779,6 +779,129 @@ test('⑰c超时不覆盖既有观测：先 healthy 再超时→仍 healthy+note
   } finally { console.error = origErr }
 })
 
+// ===== ⑬f 探测恢复熔断解除（task-mvvw71nc）：连续 2 次探测通过翻绿，红态可证活 =====
+// 用户 2026-10-31 实测：「配置模型熔断后状态变红，再下一个探测周期是否会变回来，实测没有」——旧 ok 臂只写
+// observed='healthy'，从不碰 badModels 熔断表，syncModelHealth 覆盖闸每次重查熔断表压回 circuit（探测能证
+// 「可调用」却解除不了「不可调」判定）。修法（用户拍板「乙+连击」）：探测 ok 臂累计 probeOkStreak，连续 2 次
+// （15min 双周期确认）→ delete badModels + 连击清零 + 重派生 + 通知；中断（失败/超时/degraded）计数清零；
+// 单次成功不复位（不放过「能回 1 token 但跑长任务就崩」的偶发病模型）。
+function mkRecoverState(k) {
+  var st = { modelHealth: {}, modelCooldown: {}, badModels: {}, probeOkStreak: {}, modelFailStreak: {} }
+  st.badModels[k] = true
+  st.modelFailStreak[k] = 3
+  st.modelHealth[SID] = {}
+  st.modelHealth[SID]['p/a'] = { state: 'circuit', observed: 'healthy', observedNote: '主动探测通过', lastProbe: '2026-10-30T00:00:00.000Z', lastSeen: '2026-10-30T00:00:00.000Z', circuitNote: '连续 3 次 spawn/续跑即被宿主拆除（模型失败），已熔断', recentRuns: [] }
+  return st
+}
+// 捕获 pushSysNote 的派发桩（mkDispatch 的 pushSysNote 是 no-op，恢复通知投递断言需要显式捕获）；
+// 接线与 mkDispatch 同形，state 各表按引用共享（probeOkStreak 由测试预置，工厂就地取用同一引用）。
+function mkRecoverDispatch(board, ctxOver, state, notes) {
+  var shared = Object.assign({ knownSessions: {}, dispatchedEver: {}, teamModeCache: {}, activeRuns: {} }, state)
+  return createDispatch(
+    Object.assign({ fs: {}, effect: function () {}, get: function () { return null } }, ctxOver || {}),
+    shared,
+    {
+      rt: async function () { return board }, wt: async function () {},
+      mutateLocked: async function (sid, fn) { return fn(board) },
+      kickCycle: function () {}, rootForSession: function () { return { id: SID } },
+      sessionCwd: function () { return '' }, withTimeout: function (p) { return p }, runsFor: function (sid) { return shared.activeRuns[sid] || (shared.activeRuns[sid] = {}) },
+      feedbackOn: function () { return true }, pushSysNote: function (sid, text) { notes.push({ sid: sid, text: String(text) }) }, maybeNotify: function () {}, notifyTaskDone: function () {},
+    })
+}
+
+test('⑬f探测恢复熔断解除：单次通过不复位；连续 2 次→badModels 清除+连击清零+翻 healthy+通知投递', async () => {
+  var board = seed(SID); board.workerModel = 'p/a'
+  var k = SID + '|p/a'
+  var origErr = console.error; console.error = function () {}
+  try {
+    // ① 已熔断 + 探测成功 1 次 → 仍 circuit（计数 1，badModels/连击未动，零通知）
+    var calls = [], notes = [], st = mkRecoverState(k)
+    var d = mkRecoverDispatch(board, mkProbeScriptCtx(calls, ['stop']), st, notes)
+    var r1 = await d.probeConfiguredModels(SID, board)
+    assert.equal(r1.healthy, 1)
+    assert.equal(st.badModels[k], true, '单次探测成功不解除熔断（过滤偶发响应）')
+    assert.equal(st.probeOkStreak[k], 1, '恢复连击累计 1')
+    assert.equal(st.modelFailStreak[k], 3, '熔断连击未被单次探测清零')
+    assert.equal(st.modelHealth[SID]['p/a'].state, 'circuit', '覆盖闸仍压回 circuit（半程红态）')
+    assert.equal(st.modelHealth[SID]['p/a'].observed, 'healthy', 'observed 已翻 healthy（覆盖态仍 circuit）')
+    assert.equal(notes.length, 0, '未复位不发通知')
+
+    // ② 连续第 2 次 → 解除：badModels 清除 + 连击清零 + 恢复计数清零 + state 翻 healthy + 通知投递
+    var r2 = await d.probeConfiguredModels(SID, board)
+    assert.equal(r2.healthy, 1)
+    assert.equal(k in st.badModels, false, '连续 2 次探测通过 → 解除熔断')
+    assert.equal(k in st.modelFailStreak, false, '熔断连击清零（复位对称操作）')
+    assert.equal(k in st.probeOkStreak, false, '恢复连击复位后清零')
+    assert.equal(st.modelHealth[SID]['p/a'].state, 'healthy', '熔断解除后重派生翻绿（🔴→🟢）')
+    assert.equal(st.modelHealth[SID]['p/a'].observed, 'healthy')
+    assert.equal(notes.length, 1, '解除熔断投递系统通知')
+    assert.equal(notes[0].sid, SID)
+    assert.equal(notes[0].text, '模型 p/a 连续 2 次探测通过，熔断已解除，恢复调度')
+
+    // ⑤ 解除后再探测成功：未熔断 → 零副作用（不重建计数/不重复通知）
+    await d.probeConfiguredModels(SID, board)
+    assert.equal(k in st.probeOkStreak, false, '未熔断模型探测成功零副作用（不建多余计数）')
+    assert.equal(notes.length, 1, '未熔断不再发通知')
+  } finally { console.error = origErr }
+})
+
+test('⑬f2探测恢复中断清零：中途一次失败→计数清零重新计；degraded 🟡 不计入不复位', async () => {
+  var board = seed(SID); board.workerModel = 'p/a'
+  var k = SID + '|p/a'
+  var origErr = console.error; console.error = function () {}
+  try {
+    // ③ 成功 1 次 → 失败 1 次（计数清零）→ 成功 1 次：仍 circuit 且计数 1（必须真的连续，偶发成功不叠加）
+    var calls = [], notes = [], st = mkRecoverState(k)
+    var d = mkRecoverDispatch(board, mkProbeScriptCtx(calls, ['stop', { error: 'boom' }, 'stop', 'stop']), st, notes)
+    await d.probeConfiguredModels(SID, board)
+    assert.equal(st.probeOkStreak[k], 1)
+    var rf = await d.probeConfiguredModels(SID, board)
+    assert.equal(rf.healthy, 0)
+    assert.equal(k in st.probeOkStreak, false, '中途一次探测失败 → 恢复计数清零')
+    assert.equal(st.badModels[k], true, '失败不复位熔断')
+    await d.probeConfiguredModels(SID, board)
+    assert.equal(st.probeOkStreak[k], 1, '清零后重新计（不是累计 2）')
+    assert.equal(st.badModels[k], true, '仍需再连续一次才解除')
+    assert.equal(st.modelHealth[SID]['p/a'].state, 'circuit')
+    assert.equal(notes.length, 0)
+    await d.probeConfiguredModels(SID, board)
+    assert.equal(k in st.badModels, false, '清零重计后连续 2 次才解除')
+    assert.equal(notes.length, 1)
+
+    // ④ degraded 🟡（纯空响应供应商怪癖）非探测成功 → 不复位且计数清零（只有 🟢 通过才算证活）
+    var calls2 = [], notes2 = [], st2 = mkRecoverState(k)
+    var d2 = mkRecoverDispatch(board, mkProbeScriptCtx(calls2, ['stop', 'empty', 'empty']), st2, notes2)
+    await d2.probeConfiguredModels(SID, board)
+    assert.equal(st2.probeOkStreak[k], 1)
+    var rd = await d2.probeConfiguredModels(SID, board)
+    assert.equal(rd.degraded, 1, '纯空响应判 🟡degraded 存活')
+    assert.equal(k in st2.probeOkStreak, false, 'degraded 不计入恢复连击（清零）')
+    assert.equal(st2.badModels[k], true, 'degraded 不复位熔断')
+    assert.equal(st2.modelHealth[SID]['p/a'].state, 'circuit', '熔断覆盖态仍在（degraded 未解除）')
+    assert.equal(notes2.length, 0, 'degraded 不发解除通知')
+
+    // ④b 探测超时（判定保留臂）同样非成功 → 计数清零不复位
+    var calls4 = [], notes4 = [], st4 = mkRecoverState(k)
+    await mkRecoverDispatch(board, mkProbeScriptCtx(calls4, ['stop']), st4, notes4).probeConfiguredModels(SID, board)
+    assert.equal(st4.probeOkStreak[k], 1)
+    var ctx4 = mkRecordTimerCtx(mkProbeScriptCtx(calls4, ['hang']), [])
+    await mkRecoverDispatch(board, ctx4, st4, notes4).probeConfiguredModels(SID, board)
+    assert.equal(k in st4.probeOkStreak, false, '探测超时（判定保留）同样不计入恢复连击')
+    assert.equal(st4.badModels[k], true, '超时不复位熔断')
+    assert.equal(st4.modelHealth[SID]['p/a'].state, 'circuit')
+    assert.equal(notes4.length, 0)
+
+    // ⑤ 未熔断模型：探测成功零副作用（不建计数/不通知）
+    var calls3 = [], notes3 = [], st3 = { modelHealth: {}, modelCooldown: {}, badModels: {}, probeOkStreak: {}, modelFailStreak: {} }
+    var d3 = mkRecoverDispatch(board, mkProbeScriptCtx(calls3, ['stop', 'stop']), st3, notes3)
+    await d3.probeConfiguredModels(SID, board)
+    await d3.probeConfiguredModels(SID, board)
+    assert.deepEqual(Object.keys(st3.probeOkStreak), [], '未熔断模型探测成功零副作用（不建多余计数）')
+    assert.deepEqual(Object.keys(st3.badModels), [])
+    assert.equal(notes3.length, 0, '未熔断无通知')
+  } finally { console.error = origErr }
+})
+
 async function runVerifierHealth(result) {
   var settle = null, pending = new Promise(function (resolve) { settle = resolve })
   var board = seed(SID); board.verifierModel = 'p/v'; board.tasks = [mkTask({ status: 'verifying' })]

package/test/runtime-health.test.mjs

@@ -168,8 +168,9 @@ test('⑤b 终止未生效 hint：terminateFailNote → err 级红条（sticky
 // ===== ⑥ host 挂点源码断言 =====
 test('⑥ host 挂点源码断言：dispatch 心跳打点 / rpc 接线 / index state 容器', function () {
   var srcDispatch = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  var srcSettle = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   assert.ok(srcDispatch.indexOf('poolLastOkAt') >= 0, 'dispatch.mjs 应有 poolCycle 成功轮心跳打点')
-  assert.ok(srcDispatch.indexOf('settleLastOkAt') >= 0, 'dispatch.mjs 应有 settleRunRecord 打点')
+  assert.ok(srcSettle.indexOf('settleLastOkAt') >= 0, 'settle.mjs 应有 settleRunRecord 打点')
   assert.ok(srcDispatch.indexOf('reapNote') >= 0, 'dispatch.mjs 应有幽灵回收一次性记录打点')
   assert.ok(srcDispatch.indexOf('dispatchOk') >= 0, 'dispatch.mjs 应有成功派发计数')
   var srcRpc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')

package/test/scorecard-data.test.mjs

@@ -196,7 +196,8 @@ test('卡1④：helper 纯函数零 IO——fs 门面全部打爆后照跑不触
 
 // ===== ⑤ 补落账接线（源码级断言）=====
 test('卡1⑤：模型补落账接线——accumulateRunUsage 回填空 model / index re-export / helper 落在 usage.mjs', () => {
-  const disp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  // 拆分第 7 刀（task-mvt8c1yx-7，仲裁扩权放行）：accumulateRunUsage 随源码搬至 lib/settle.mjs——断言随源码重指 settle 源
+  const disp = readFileSync(new URL('../lib/settle.mjs', import.meta.url), 'utf8')
   const usage = readFileSync(new URL('../lib/usage.mjs', import.meta.url), 'utf8')
   const idx = readFileSync(new URL('../index.mjs', import.meta.url), 'utf8')
   // 补落账：run 级留账写回时，条目 model 为空且日志有模型名 → 回填（只填空不覆盖）