dsh-agent-board 1.8.0 → 1.8.2

package/test/core.test.mjs

@@ -530,6 +530,27 @@ test('buildWorkerPrompt: 大文件交付纪律（write 主体+edit 续块）注
   assert.doesNotMatch(vBody, /大文件交付纪律/)
 })
 
+test('buildWorkerPrompt: 前轮半成品提示——runs[] 有已落定 worker run 才出现（task-mvbeallq 残影治理②）', () => {
+  // 有前轮已落定 worker run → 提示先 git status 盘点续作（残影被补停/池故障重派后工作区可能有半成品）
+  const t1 = mkTask({ id: 'pr1', runs: [{ role: 'worker', id: 'c1', at: '2026-01-01T00:00:00Z', outcome: 'timeout/error', continuable: true }] })
+  const p1 = core.buildWorkerPrompt(t1)
+  assert.match(p1, /本卡有前轮 run 的痕迹——先 git status 看工作区有无未提交的半成品改动/)
+  assert.match(p1, /能续作就在其基础上续作，别盲目从零推倒重来/)
+  // 无前轮 run（runs 缺省/空数组）→ 不出现
+  assert.doesNotMatch(core.buildWorkerPrompt(mkTask({ id: 'pr2' })), /前轮 run 的痕迹/)
+  assert.doesNotMatch(core.buildWorkerPrompt(mkTask({ id: 'pr2b', runs: [] })), /前轮 run 的痕迹/)
+  // 只有 verifier run → 不出现（只看 worker 痕迹）
+  assert.doesNotMatch(core.buildWorkerPrompt(mkTask({ id: 'pr3', runs: [{ role: 'verifier', id: 'v1', outcome: 'completed' }] })), /前轮 run 的痕迹/)
+  // 前轮 worker 仍 running（僵尸/在跑留档）→ 不出现（已落定才算痕迹）
+  assert.doesNotMatch(core.buildWorkerPrompt(mkTask({ id: 'pr4', runs: [{ role: 'worker', id: 'c2', outcome: 'running' }] })), /前轮 run 的痕迹/)
+  // 各种已落定结局都算痕迹（completed / incomplete / stale-closed / terminated）
+  assert.match(core.buildWorkerPrompt(mkTask({ id: 'pr5', runs: [{ role: 'worker', id: 'c3', outcome: 'completed' }] })), /前轮 run 的痕迹/)
+  assert.match(core.buildWorkerPrompt(mkTask({ id: 'pr6', runs: [{ role: 'worker', id: 'c4', outcome: 'incomplete' }] })), /前轮 run 的痕迹/)
+  assert.match(core.buildWorkerPrompt(mkTask({ id: 'pr7', runs: [{ role: 'worker', id: 'c5', outcome: 'stale-closed' }] })), /前轮 run 的痕迹/)
+  // verifier prompt 不含此提示（提示只进 Worker）
+  assert.doesNotMatch(core.buildVerifierPrompt(t1), /前轮 run 的痕迹/)
+})
+
 // ===== 预研上下文段（瘦身分离形态，task-muvjs392）：笔记全文 + 文件清单，不含文件内容本体 =====
 // 形态：### 主窗口调研笔记（全文 ≤8000 字符）\n…\n\n### 调研文件清单（- 路径:L起-L止 — 一句用途）
 test('buildContextPackSection: 空清单返回空串', () => {
@@ -1433,7 +1454,9 @@ test('create-task RPC: 起草 lint 落卡 lintWarnings[]，get-tasks 透出（
   const h = mkRpcHandlers(board)
   const r = await h['create-task']({ title: '修复 lint 规则', description: '明确描述', touches: ['src/**'], acceptance: 'node --test' })
   assert.equal(r.ok, true)
-  assert.deepEqual(r.task.lintWarnings, [core.TREE_GLOB_LINT])
+  // task-mvbealtf：自动派发形态的建卡返回体 lintWarnings 尾部带派发预警（瞬态）——
+  // 落卡/get-tasks 透出的持久 lintWarnings 不含该行（详情页不残留过期文案）
+  assert.deepEqual(r.task.lintWarnings, [core.TREE_GLOB_LINT, core.DISPATCH_NOW_LINT])
   const got = await h['get-tasks']({})
   assert.deepEqual(got.tasks[0].lintWarnings, [core.TREE_GLOB_LINT])
 })
@@ -1476,6 +1499,101 @@ test('起草 lint 接线：四入口 draftLint 落卡 + 详情 ⚠️ 行 + READ
   assert.equal((rootReadme.match(/lintWarnings\[\]/g) || []).length, 2) // 根 README 同步双处
 })
 
+// ===== 建卡派发预警（task-mvbealtf / 巡检反馈 n-mvba2neatqoa）=====
+// 自动派发形态的建卡返回体 lintWarnings 尾部追加 DISPATCH_NOW_LINT（瞬态不落卡）；
+// draft/manual/direct/依赖未满足形态不带。纯函数在 core.mjs，双通道经 rpc.mjs 接线。
+
+test('willAutoDispatch: 自动派发形态矩阵（pending+auto+非direct+依赖满足才 true）', () => {
+  const depDone = mkTask({ id: 'dep', status: 'resolved' })
+  const depOpen = mkTask({ id: 'dep', status: 'pending' })
+  // 命中：pending + auto + full/work + 无依赖（或依赖已 resolved）
+  assert.equal(core.willAutoDispatch(mkBoard([]), mkTask({})), true)
+  assert.equal(core.willAutoDispatch(mkBoard([]), mkTask({ pipeline: 'work' })), true)
+  assert.equal(core.willAutoDispatch(mkBoard([depDone]), mkTask({ dependsOn: ['dep'] })), true)
+  // 不命中：draft / manual / direct / 依赖未满足
+  assert.equal(core.willAutoDispatch(mkBoard([]), mkTask({ status: 'draft' })), false)
+  assert.equal(core.willAutoDispatch(mkBoard([]), mkTask({ assignMode: 'manual' })), false)
+  assert.equal(core.willAutoDispatch(mkBoard([]), mkTask({ pipeline: 'direct' })), false)
+  assert.equal(core.willAutoDispatch(mkBoard([depOpen]), mkTask({ dependsOn: ['dep'] })), false)
+  // 异常入参零炸
+  assert.equal(core.willAutoDispatch(null, null), false)
+  assert.equal(core.willAutoDispatch(mkBoard([]), null), false)
+})
+
+test('appendDispatchWarning: 命中换浅拷贝追加预警（持久本体不动），未命中原样返回', () => {
+  const t = mkTask({})
+  t.lintWarnings = [core.TITLE_NO_VERB_LINT]
+  const out = { ok: true, task: t }
+  const r = core.appendDispatchWarning(out, mkBoard([]), t)
+  assert.deepEqual(r.task.lintWarnings, [core.TITLE_NO_VERB_LINT, core.DISPATCH_NOW_LINT])
+  assert.deepEqual(t.lintWarnings, [core.TITLE_NO_VERB_LINT]) // 持久数组不被污染
+  assert.notEqual(r.task, t)                                  // 响应是浅拷贝，本体不换
+  // 未命中：draft 形态原样返回（同一 task 引用，零字段漂移）
+  const td = mkTask({ status: 'draft' })
+  const outd = { ok: true, task: td }
+  assert.equal(core.appendDispatchWarning(outd, mkBoard([]), td).task, td)
+  // 异常入参原样返回
+  assert.equal(core.appendDispatchWarning(null, mkBoard([]), t), null)
+  assert.equal(core.appendDispatchWarning({ ok: false }, mkBoard([]), t).task, undefined)
+})
+
+test('create-task RPC: 自动派发形态返回体带派发预警；draft/direct 形态不带（双形态断言）', async () => {
+  // ① 自动派发形态（缺省 draft=false + auto + 非 direct + 无依赖）→ 返回体带预警，落卡不带
+  let board = mkBoard([])
+  let h = mkRpcHandlers(board)
+  let r = await h['create-task']({ title: '修复预警', description: '明确描述', acceptance: 'node --test' })
+  assert.equal(r.ok, true)
+  assert.ok(r.task.lintWarnings.includes(core.DISPATCH_NOW_LINT))
+  assert.ok(!board.tasks[0].lintWarnings.includes(core.DISPATCH_NOW_LINT)) // 瞬态不落卡
+  // ② draft:true 占位形态 → 不带
+  board = mkBoard([])
+  h = mkRpcHandlers(board)
+  r = await h['create-task']({ title: '修复预警', description: '明确描述', acceptance: 'node --test', draft: true })
+  assert.equal(r.ok, true)
+  assert.ok(!r.task.lintWarnings.includes(core.DISPATCH_NOW_LINT))
+  // ③ direct 管线形态（不进池）→ 不带
+  board = mkBoard([])
+  h = mkRpcHandlers(board)
+  r = await h['create-task']({ title: '解释一下 lint 是什么', description: '说明一下', pipeline: 'direct' })
+  assert.equal(r.ok, true)
+  assert.ok(!(r.task.lintWarnings || []).includes(core.DISPATCH_NOW_LINT))
+  // ④ 依赖未满足形态（不会立即派发）→ 不带
+  board = mkBoard([mkTask({ id: 'dep', title: '修复前置', status: 'pending' })])
+  h = mkRpcHandlers(board)
+  r = await h['create-task']({ title: '修复预警', description: '明确描述', acceptance: 'node --test', dependsOn: ['dep'] })
+  assert.equal(r.ok, true)
+  assert.ok(!r.task.lintWarnings.includes(core.DISPATCH_NOW_LINT))
+})
+
+test('task_create 工具: 自动派发形态返回体带派发预警；draft:true 不带（工具通道接线）', async () => {
+  // ① 自动派发形态 → 带
+  let board = mkBoard([])
+  let h = mkRpcHandlers(board)
+  let r = await h.__tools['task_create'].execute({ title: '修复预警', description: '明确描述', acceptance: 'node --test' })
+  assert.equal(r.ok, true)
+  assert.ok(r.task.lintWarnings.includes(core.DISPATCH_NOW_LINT))
+  assert.ok(!board.tasks[0].lintWarnings.includes(core.DISPATCH_NOW_LINT)) // 落卡不含
+  // ② draft:true → 不带
+  board = mkBoard([])
+  h = mkRpcHandlers(board)
+  r = await h.__tools['task_create'].execute({ title: '修复预警', description: '明确描述', acceptance: 'node --test', draft: true })
+  assert.equal(r.ok, true)
+  assert.ok(!r.task.lintWarnings.includes(core.DISPATCH_NOW_LINT))
+})
+
+test('建卡派发预警接线：双通道调用 + draft 参数说明加重 + core 三件套（源码级断言）', () => {
+  const host = hostSrc()
+  // 双通道同口径：task_create 工具 + create-task RPC 各一次调用
+  assert.equal((host.match(/appendDispatchWarning\(__out, d, t\)/g) || []).length, 1) // task_create 工具
+  assert.equal((host.match(/appendDispatchWarning\(out, d, t\)/g) || []).length, 1)  // create-task RPC
+  // 工具 draft 参数说明加重：点名占位/测试卡请显式 draft:true
+  assert.match(host, /不派发的占位\/测试卡请显式 draft:true/)
+  const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
+  assert.match(coreSrc, /export function willAutoDispatch\(d, t\)/)
+  assert.match(coreSrc, /export function appendDispatchWarning\(out, d, t\)/)
+  assert.match(coreSrc, /DISPATCH_NOW_LINT = '此卡将立即进入派发池（约 1s 内被 Worker 领取）；想先占位请 draft:true 建草稿'/)
+})
+
 test('epicPrecheck: 字段有无 + 路径存在性（exists 注入），direct/归档子任务不参与', () => {
   const kids = [
     mkTask({ id: 'k1', title: '无材料', parentId: 'ep', context: { files: [], notes: '' } }),
@@ -3636,7 +3754,7 @@ test('可续跑 Worker⑩（卡2④）：interrupt 失败 → 结算不卡死（
   assert.equal(t.claimedBy, 'child-2')
 })
 
-test('可续跑 Worker⑪（卡2⑤）：workerContinuable=false → 续跑机制整体短路（零 sendMessage/零 interrupt），一次性 dispose 兜底逐字不变', async () => {
+test('可续跑 Worker⑪（卡2⑤）：workerContinuable=false → 续跑机制整体短路（零 sendMessage/零冷复活），一次性 dispose 兜底不变（task-mv8wuznb 起结算补停 interrupt 一枪）', async () => {
   const parent = { id: FULL_SID }
   const sent = []
   const interrupted = []
@@ -3656,7 +3774,10 @@ test('可续跑 Worker⑪（卡2⑤）：workerContinuable=false → 续跑机
   await h.dispatch.poolCycle(FULL_SID)
   for (let i = 0; i < 4; i++) await flush()
   assert.deepEqual(sent, [])                    // 零冷复活
-  assert.deepEqual(interrupted, [])             // 零 interrupt（一次性路径只 dispose）
+  // task-mv8wuznb 语义修订：一次性 run 结算落定后主动 interrupt 子会话（「结算即销毁」的补停，
+  // 堵「结算≠停止」空转洞——实证 verifier 落账后空转 8h）。这枪是销毁收尾，与续跑机制的
+  // 「interrupt 留存」（endContinuable，打断 turn 留会话）语义相反、互不干扰。
+  assert.deepEqual(interrupted, ['run-1'])       // 一次性结算补停恰一枪（dispose 之外的增量）
   assert.ok(disposed >= 1)                      // 旧兜底照旧（run.dispose）
   assert.equal(t.status, 'pending')             // 失败结算语义不变
   assert.equal(t.retryCount, 1)
@@ -3812,9 +3933,11 @@ test('史诗语义层接线：poolCycle 派发分支触发父卡流转 + get-tas
   // tasksHash（task-mutrtwin）、hooks 浅校验（normalizeHooks/mergeHooks，本批 hooks=agent run）、
   // 自测指南归一（normalizeUserTest，task-muxyyvg0）扩展；
   // dispatch.mjs 解构表尾部追加 hook 族（buildHookPrompt/hookOn/hookSetState/gsb）与驳回包 helper（pushRejection，task-muvg15p5）、
+  // depsSatisfied（task-mv9yupm4，spawn 落闸锁内补验依赖）、
   // Verifier 验收员加餐常量（VERIFIER_PERSONA/VERIFIER_TOOL_FILTER，task-muy3gm03）
-  assert.match(host, /parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER \} = core/)
-  assert.match(host, /boardHome, aggregateChildStats, createTaskWarnings, epicPrecheck, epicPrecheckNote, attachContextSuggestions, REJECT_REDISPATCH_HINT, tasksHash, normalizeHooks, mergeHooks, pushRejection, normalizeUserTest, draftLint \} = core/)
+  assert.match(host, /parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER \} = core/)
+  // rpc.mjs 解构表尾部再随建卡派发预警（appendDispatchWarning，task-mvbealtf）扩展
+  assert.match(host, /boardHome, aggregateChildStats, createTaskWarnings, epicPrecheck, epicPrecheckNote, attachContextSuggestions, REJECT_REDISPATCH_HINT, tasksHash, normalizeHooks, mergeHooks, pushRejection, normalizeUserTest, draftLint, appendDispatchWarning \} = core/)
   // 既有「全子任务 resolved → 父 verifying」逻辑不动（checkParentAuto 仍在 verifyApply 链路；
   // 但其内部已委托共享 helper maybeAutoCloseParent——单一判定口径，core.mjs 不在 hostSrc 清单，单独读）
   const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
@@ -6119,6 +6242,98 @@ test('set-board-config 模型校验④b：provider 枚举失败不阻塞，其
   assert.equal(board.workerModel, 'kimi/kimi-k2')
 })
 
+// ===== 板级配置审计行 + 模型下拉两段式（task-mv9yuq2l，实证 n-mv8ki92qnhdq：verifierModel 神隐回退零留痕无从审计）=====
+// ① set-board-config 成功写入落 {key, from, to, actor, at}；拒写/非白名单不落 ② 截尾 50 条 + get-tasks 透出
+// ③ seed/normalizeBoard 归一兜底 ④ 下拉两段式源码级：选中不调 rpc、点保存才调
+test('配置审计①：set-board-config 成功写入落审计行 {key, from, to, actor, at}；拒写/非白名单不落', async () => {
+  const board = mkBoard([])
+  const h = mkRpcHandlers(board, {}, mkLlmCtx(MOCK_MODELS))
+  await h['set-board-config']({ key: 'maxWorkers', value: 5 })
+  assert.equal(board.configLog.length, 1)
+  const e1 = board.configLog[0]
+  assert.equal(e1.key, 'maxWorkers')
+  assert.equal(e1.from, null) // 老看板首写（无该字段）→ null
+  assert.equal(e1.to, 5)
+  assert.equal(e1.actor, 'tester') // rpcActor → getActorId()
+  assert.ok(typeof e1.at === 'string' && e1.at.length > 0) // ISO 时间戳在位
+  // 二次写入：from 读到上轮落盘值（审计链可追「从什么改成什么」）
+  await h['set-board-config']({ key: 'maxWorkers', value: 8 })
+  assert.equal(board.configLog.length, 2)
+  assert.equal(board.configLog[1].from, 5)
+  assert.equal(board.configLog[1].to, 8)
+  // to 记钳制后的实际落盘真值（入参 999 → 钳到 10），审计关心真值不是入参
+  await h['set-board-config']({ key: 'maxWorkers', value: 999 })
+  assert.equal(board.configLog[2].to, 10)
+  // 模型键（带枚举校验通道）成功也落：from/to 是 trim 后真值
+  await h['set-board-config']({ key: 'verifierModel', value: ' kimi/kimi-k2 ' })
+  const em = board.configLog[3]
+  assert.equal(em.key, 'verifierModel'); assert.equal(em.from, null); assert.equal(em.to, 'kimi/kimi-k2')
+  // 校验拒写（非法模型 id）不落审计行
+  const rBad = await h['set-board-config']({ key: 'verifierModel', value: 'kimi/kimi-k3' })
+  assert.equal(rBad.ok, false)
+  assert.equal(board.configLog.length, 4)
+  // 非白名单键：老契约照返 ok:true，但无实际写入 → 不落审计行
+  const rX = await h['set-board-config']({ key: 'nonsenseKey', value: 1 })
+  assert.equal(rX.ok, true)
+  assert.equal(board.configLog.length, 4)
+})
+
+test('配置审计②：截尾留最新 50 条；get-tasks 透出（老看板缺字段=空数组）', async () => {
+  const board = mkBoard([])
+  const h = mkRpcHandlers(board)
+  for (let i = 0; i < 55; i++) await h['set-board-config']({ key: 'maxWorkers', value: (i % 10) + 1 })
+  assert.equal(board.configLog.length, 50) // 截尾：容量恒定 50
+  assert.equal(board.configLog[49].to, (54 % 10) + 1) // 最新一条 = 第 55 次写入
+  assert.equal(board.configLog[0].to, (5 % 10) + 1)   // 最旧一条 = 第 6 次写入（前 5 条已被裁掉）
+  const got = await h['get-tasks']({})
+  assert.ok(Array.isArray(got.configLog))
+  assert.equal(got.configLog.length, 50)
+  assert.equal(got.configLog[49].key, 'maxWorkers')
+  // 老看板（磁盘文件无 configLog 字段）：透出空数组，不炸
+  const h2 = mkRpcHandlers(mkBoard([]))
+  assert.deepEqual((await h2['get-tasks']({})).configLog, [])
+})
+
+test('配置审计③：seed 初值自带 + normalizeBoard 老看板/脏值兜底（core 层归一）', () => {
+  assert.deepEqual(core.seed('s1').configLog, []) // 新板种子自带
+  const d = { tasks: [] }
+  core.normalizeBoard(d)
+  assert.deepEqual(d.configLog, []) // 老看板缺字段 → 补空数组
+  const d2 = { tasks: [], configLog: 'dirty' }
+  core.normalizeBoard(d2)
+  assert.deepEqual(d2.configLog, []) // 脏值收敛
+  const d3 = { tasks: [], configLog: [{ key: 'maxWorkers', from: 3, to: 5, actor: 'a', at: 't' }] }
+  core.normalizeBoard(d3)
+  assert.equal(d3.configLog.length, 1) // 合法存量原样保留
+})
+
+test('模型下拉两段式④（源码级）：ModelCfg 选中只改草稿态，点 ✓ 保存才调 rpc；组装产物同步', () => {
+  const src = readFileSync(new URL('../lib/client/dashboard.js', import.meta.url), 'utf8')
+  const start = src.indexOf('function ModelCfg(props)')
+  assert.ok(start >= 0, 'dashboard.js 应定义 ModelCfg')
+  const end = src.indexOf('function ZoomCfg(', start)
+  assert.ok(end > start, 'ModelCfg 之后应紧跟 ZoomCfg（切片边界）')
+  const body = src.slice(start, end)
+  // ① pick 只写本地草稿态（setVal + setDirty），函数体不得出现 rpc（即点即写是事故原形，绝不回退）
+  const pickM = body.match(/function pick\(v\) \{[^}]*\}/)
+  assert.ok(pickM, 'ModelCfg 应定义 pick')
+  assert.equal(pickM[0].indexOf('rpc('), -1, 'pick 不得直接调 rpc（两段式红线）')
+  assert.match(pickM[0], /setVal\(v\)/)
+  assert.match(pickM[0], /setDirty\(v !== \(props\.value \|\| ''\)\)/) // dirty 对比服务端权威值
+  // ② 提交唯一入口 = save()（rpc('set-board-config') 只住在 save 里）
+  const saveM = body.match(/function save\(\) \{[^}]*\}/)
+  assert.ok(saveM, 'ModelCfg 应定义 save')
+  assert.match(saveM[0], /rpc\('set-board-config', \{ key: cfgKey, value: \(val \|\| ''\)\.trim\(\)/)
+  // ③ 下拉分支（if (models) 到降级分支之间）：onChange 走 pick；dirty 才渲染保存键（onClick: save）
+  const selBranch = body.slice(body.indexOf('if (models)'), body.indexOf('// 降级'))
+  assert.match(selBranch, /onChange: function \(e\) \{ pick\(e\.target\.value\) \}/)
+  assert.match(selBranch, /dirty \? React\.createElement\('button', \{ onClick: save/)
+  // ④ 组装产物同步：lib/client.js 含两段式 pick，且不再残留「选中即写」的旧 pick
+  const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+  assert.match(built, /function pick\(v\) \{ setVal\(v\); setDirty\(v !== \(props\.value \|\| ''\)\) \}/)
+  assert.equal(built.indexOf("function pick(v) { setVal(v); setDirty(false); rpc('set-board-config'"), -1, '组装产物不得残留即点即写旧 pick')
+})
+
 // 熔断通知分态行为测试 harness：一次性 verifier run 失败，捕获 pushSysNote 文案 + badModels 落账
 async function runVerifierFuseCase(errText) {
   const t = mkTask({ id: 'v-fuse', title: '待验收卡', status: 'verifying' })

package/test/integration.test.mjs

@@ -2,6 +2,8 @@
 //   前半（a-d）：全链路 / 驳回重派 / dependsOn 接续 / touches 排他
 //   后半（e-i，task-muxpgq5b）：仲裁冻结时钟推进 / 回执聚合过滤 / 歧义去抖 / progress / 孤儿回收
 //   竞态根修（k-m，task-mv6c7cdm）：terminate×续跑在途落闸弃权 / 正常续跑不回归 / fresh spawn 在途弃权
+//   依赖后补根修（n-o，task-mv9yupm4）：publish 后补 dependsOn 撞在途 spawn 落闸否决+依赖落定重派 /
+//   update-task 在飞卡写依赖 warning 软提示（pending 卡不带）
 // 九场景全部跑在「真实 index.mjs apply(mockCtx)」上（卡1 harness），不改生产代码；
 // 每用例独立 mockCtx + 独立临时 HOME，互不污染（HOME env 是进程级，顶层用例默认串行，严禁并行）。
 //
@@ -641,7 +643,12 @@ test('集成l·terminate竞态②：正常续跑不回归——无 terminate 时
     var rep = await env.tools.get('board_report').execute({ taskId: 'task-l1', kind: 'complete', summary: '续跑交付', changes: '改了 l', selfTest: 'npm test 全绿', diffStat: '' })
     assert.equal(rep.ok, true)
     t = await env.waitFor(function () { var x = env.task('task-l1'); return x && x.status === 'resolved' && x.runs[1].outcome === 'completed' ? x : null }, '续跑轮交付落 resolved 且关账')
-    assert.equal(env.interrupts.length, interruptBase, '正常续跑路径零新增 interrupt（闸门不误伤）')
+    // task-mvbeallq 豁免收紧：completed 落定无续跑位（resumeTarget 只认超时/失败结局）→ settleRunRecord
+    // 尾序补停一枪（残影治理①）；除此之外续跑全程（闸门/落闸/结算）零新增 interrupt——不误伤仍成立。
+    await env.waitFor(function () { return env.interrupts.length >= interruptBase + 1 }, 'completed 落定补停在位')
+    assert.equal(env.interrupts.length, interruptBase + 1, '续跑全程仅补停一枪（completed 无续跑位），闸门不误伤')
+    assert.equal(env.interrupts[env.interrupts.length - 1].childId, child1, '补停目标=续跑轮子会话（打断 turn 不销毁会话）')
+    assert.equal(env.interrupts[env.interrupts.length - 1].authority.kind, 'ancestor', 'authority 形状同款')
   } finally { await env.cleanup() }
 })
 
@@ -694,3 +701,101 @@ test('集成m·terminate竞态③：fresh spawn 在途被 terminate → 落闸
     t = await env.waitFor(function () { var x = env.task('task-m1'); return x && x.status === 'resolved' && x.runs[0].outcome === 'completed' ? x : null }, 'resolved 收口且 run 关账')
   } finally { await env.cleanup() }
 })
+
+// ===== 场景 n：dependsOn 后补撞在途 spawn 根修①（task-mv9yupm4，ontology 实证 n-mv8zdii54ajf）=====
+// 竞态时序复刻：B 空依赖 publish → 立即被 claim 占位、spawn 在途挂起 → update-task 后补
+// dependsOn=[F1]（写入成功+warning 软提示，但 F1 未 resolved）→ 放行 spawn。修复前：落闸不验依赖，
+// 卡照跑（depsSatisfied 只闸 pickDispatch 挑候选一刻，闸不到在途窗口）。修复后：落闸锁内重验
+// depsSatisfied=false → 弃权（interrupt 新建子会话 + 不落档不注册）+ 占位回退 pending；F1 落定后
+// 下一轮 cycle 正常派发 B，全程单 run 收口。
+test('集成n·dependsOn后补①：publish 后补依赖撞在途 spawn → 落闸否决回 pending，依赖落定后正常派发', async () => {
+  var env = createMockCtx()
+  try {
+    plugin.apply(env.ctx)
+    // spawn 挂起只针对 B（按 label 过滤）：依赖 F1 的派发不受影响
+    var origStartC = env.ctx.subagents.startContinuable
+    var spawnHold = null
+    var releaseSpawn = null
+    env.ctx.subagents.startContinuable = function (o) {
+      if (o && o.label === 'worker:task-nb' && spawnHold) return spawnHold.then(function () { return origStartC(o) })
+      return origStartC(o)
+    }
+    // 依赖 F1 先建先派（在跑未 resolved → 后补的依赖处于未满足态）
+    await createTask(env, 'task-na', { pipeline: 'work' })
+    await env.clock.advance(50)
+    await env.waitFor(function () { return env.continuables.length >= 1 }, 'F1 spawn 发生')
+    var childF1 = env.continuables[0].childId
+    await env.waitFor(function () { var x = env.task('task-na'); return x && x.status === 'in-progress' && x.claimedBy === childF1 ? x : null }, 'F1 落卡 in-progress')
+    // B 空依赖 publish → 立即被 claim，spawn 在途挂起（在途窗口由测试掌控）
+    spawnHold = new Promise(function (res) { releaseSpawn = res })
+    await createTask(env, 'task-nb', { pipeline: 'work' })
+    await env.clock.advance(50)
+    await env.waitFor(function () { var x = env.task('task-nb'); return x && x.status === 'in-progress' && x.claimedBy === 'spawn-pending' ? x : null }, 'B 占位 claim 落卡，spawn 在途')
+    // ===== 在途窗口内后补依赖（撞窗）：写入成功（不拒写）+ warning 软提示（在飞卡）=====
+    var upd = await env.rpc('update-task', { sessionId: env.sid, taskId: 'task-nb', dependsOn: ['task-na'] })
+    assert.equal(upd.ok, true, '后补依赖写入成功（软提示不拒写）')
+    assert.equal(upd.warning, '卡已在执行中，依赖变更不影响本次 run', '在飞卡写依赖带 warning 字段')
+    assert.deepEqual(env.task('task-nb').dependsOn, ['task-na'], '依赖已落卡')
+    // ===== 放行 spawn → 落闸锁内重验 depsSatisfied=false → 否决 =====
+    spawnHold = null
+    releaseSpawn()
+    await env.waitFor(function () { return env.continuables.length >= 2 }, 'B 的被否 spawn 实际建过子会话')
+    var childB1 = env.continuables[1].childId
+    await env.waitFor(function () { return env.interrupts.some(function (x) { return x.childId === childB1 }) }, '被否 spawn 的新建子会话立刻 interrupt（防空跑烧上下文）')
+    var tb = await env.waitFor(function () { var x = env.task('task-nb'); return x && x.status === 'pending' && !x.claimedBy ? x : null }, '依赖否决：占位条件化回退 pending')
+    assert.ok(!tb.runs || tb.runs.length === 0, '被否派发不落 run 留档（在卡面从未存在过）')
+    assert.deepEqual(transitions(tb), ['created→pending', 'pending→in-progress', 'in-progress→pending'], '占位 claim + 否决回退两段历史')
+    // 依赖未落定期间不再重派 B（pickDispatch 的 depsSatisfied 门控接管）
+    await env.clock.advance(50)
+    assert.equal(env.continuables.length, 2, '依赖未满足：B 不再重派')
+    assert.equal(env.sendMessages.length, 0, 'B 无留档可续（续跑通道不触发）')
+    // ===== 依赖落定 → 下一轮正常派发 B（断言②）=====
+    var repF1 = await env.tools.get('board_report').execute({ taskId: 'task-na', kind: 'complete', summary: 'F1 交付', changes: '改了 na', selfTest: 'npm test 全绿', diffStat: '' })
+    assert.equal(repF1.ok, true)
+    await env.waitFor(function () { var x = env.task('task-na'); return x && x.status === 'resolved' ? x : null }, 'F1 resolved（work 档直落）')
+    await env.clock.advance(50)
+    await env.waitFor(function () { return env.continuables.length >= 3 }, '依赖落定后 B 正常派发')
+    var childB2 = env.continuables[2].childId
+    assert.notEqual(childB2, childB1, '重派是新子会话（被弃的已 interrupt 废弃，不留续跑资格）')
+    tb = await env.waitFor(function () { var x = env.task('task-nb'); return x && x.status === 'in-progress' && x.claimedBy === childB2 ? x : null }, 'B 重新落卡 in-progress')
+    assert.equal(tb.runs.length, 1, 'B 只有一条真实落闸留档（被否决的派发零痕迹）')
+    assert.ok(!tb.runs[0].resume, 'fresh spawn 留档（无续跑资格可续）')
+    // B 正常完成 → 全链单 run 收口
+    var repB = await env.tools.get('board_report').execute({ taskId: 'task-nb', kind: 'complete', summary: 'B 交付', changes: '改了 nb', selfTest: 'npm test 全绿', diffStat: '' })
+    assert.equal(repB.ok, true)
+    tb = await env.waitFor(function () { var x = env.task('task-nb'); return x && x.status === 'resolved' && x.runs[0].outcome === 'completed' ? x : null }, 'B resolved 收口且 run 关账')
+    assert.deepEqual(transitions(tb), ['created→pending', 'pending→in-progress', 'in-progress→pending', 'pending→in-progress', 'in-progress→resolved'], '否决回退后重派全流转序列')
+  } finally { await env.cleanup() }
+})
+
+// ===== 场景 o：dependsOn 后补根修②（task-mv9yupm4）：update-task warning 边界 =====
+// warning 软提示只在「在飞卡」（in-progress 含 spawn-pending 占位 / verifying）写依赖时出现；
+// pending 卡写依赖是正常编辑路径，不带 warning。verifying 与 in-progress 同一条件分支（场景 n
+// 已覆盖 spawn-pending 形态，本场景补在跑 run 形态 + pending 反例 + 工具/RPC 双通道同口径）。
+test('集成o·dependsOn后补②：update-task 在飞卡写依赖带 warning（pending 卡不带，双通道同口径）', async () => {
+  var env = createMockCtx()
+  try {
+    plugin.apply(env.ctx)
+    await createTask(env, 'task-oa', { pipeline: 'work' })
+    await createTask(env, 'task-ob', { pipeline: 'work', dependsOn: ['task-oa'] })
+    await env.clock.advance(50)
+    await env.waitFor(function () { var x = env.task('task-oa'); return x && x.status === 'in-progress' ? x : null }, 'oa 落卡 in-progress（真实 run 在跑）')
+    assert.equal(env.task('task-ob').status, 'pending', 'ob 被 depsSatisfied 门控在 pending')
+    // pending 卡写依赖 → 正常编辑，无 warning 字段
+    var r1 = await env.rpc('update-task', { sessionId: env.sid, taskId: 'task-ob', dependsOn: ['task-oa'] })
+    assert.equal(r1.ok, true)
+    assert.ok(!('warning' in r1), 'pending 卡写依赖不带 warning 字段')
+    // in-progress（真实 run 在跑）卡写依赖 → warning（RPC 通道）
+    var r2 = await env.rpc('update-task', { sessionId: env.sid, taskId: 'task-oa', dependsOn: [] })
+    assert.equal(r2.ok, true)
+    assert.equal(r2.warning, '卡已在执行中，依赖变更不影响本次 run', '在飞卡写依赖带 warning（RPC 通道）')
+    // task_update 工具通道同口径（两份内联拷贝行为一致）
+    var r3 = await env.tools.get('task_update').execute({ taskId: 'task-oa', dependsOn: [] })
+    assert.equal(r3.ok, true)
+    assert.equal(r3.warning, '卡已在执行中，依赖变更不影响本次 run', '在飞卡写依赖带 warning（工具通道）')
+    // 收尾：oa 上报完成（ob 留 pending 不派，cleanup 直接拆环境）
+    var rep = await env.tools.get('board_report').execute({ taskId: 'task-oa', kind: 'complete', summary: 'oa 交付', changes: '改了 oa', selfTest: 'npm test 全绿', diffStat: '' })
+    assert.equal(rep.ok, true)
+    await env.waitFor(function () { var x = env.task('task-oa'); return x && x.status === 'resolved' ? x : null }, 'oa resolved 收口')
+  } finally { await env.cleanup() }
+})

package/test/late-verdict-trio.test.mjs

@@ -0,0 +1,144 @@
+// dsh-agent-board — 迟到 verdict 三连根修（task-mvf7nve8）
+// 事故实证：Verifier 调 board_verdict 漏带 verdict 字段（undefined 落账），被 lateRejected=!approved
+// 当驳回 → err 级「迟到驳回」误报 + 同一结论多次落账重复投递（J2 task-mvf2lpzk 4 次 / H2 task-mveljjwd 3 次）。
+// 三连逐一锁：① 入参校验（缺/非法 verdict 拒收带指引+零落账）② 通知分态（approved=✅迟到复核 /
+// rejected=🚨迟到驳回，banner 只 rejected 亮）③ 同指纹（taskId+by+verdict）去重零重复通知。
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createRpc } from '../lib/rpc.mjs'
+import * as core from '../lib/core.mjs'
+import { createNotify } from '../lib/notify.mjs'
+import { computeRuntimeHealthHints } from '../lib/health.mjs'
+
+const FULL_SID = 'session-mock-trio-00000000-0001'
+
+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 || {}) }
+function mkBoard(tasks) { return { version: 11, ownerSession: FULL_SID, boardMode: 'auto', verifyUserGuide: true, tasks: tasks || [] } }
+
+// RPC/工具直调 harness（与 verify-timing.test.mjs 同款，加 notifyLateApprove 捕获）
+function mkHarness(board, extra) {
+  const state = { handlers: {}, teamModeCache: {}, feedbackCache: {}, epicSplitCache: {}, poolHealth: {} }
+  const tools = {}
+  const calls = { lateRejects: [], lateApproves: [] }
+  const ctx = { tools: { register(t) { tools[t.name] = t } }, effect() {}, webServer: { register() { return () => {} } } }
+  const deps = Object.assign({
+    getActorId: () => 'verifier-child-1', resolveRoot: (x) => x,
+    toolSessionId: () => FULL_SID, rpcSessionId: () => FULL_SID,
+    rootForSession: () => null, deriveWorkMode: () => 'solo',
+    runsFor: () => ({}),
+    rt: async () => board, mutateLocked: (sid, fn) => fn(board),
+    maybeNotify: () => {}, notifyTaskDone: () => {},
+    spawnOneShot: () => {}, accumulateRunUsage: () => {}, readContextPack: async () => null,
+    pushSysNote: () => {}, sessionCwd: () => '',
+    hasActiveRun: () => false,
+    notifyLateReject: (sid, t) => { calls.lateRejects.push(t.id) },
+    notifyLateApprove: (sid, t) => { calls.lateApproves.push(t.id) },
+  }, extra || {})
+  createRpc(ctx, state, deps)
+  return { tools: tools, calls: calls, state: state }
+}
+
+// ===== ① 入参校验：缺 verdict / 非法值 → 拒收带指引 + 零落账零通知 =====
+test('① board_verdict 缺 verdict / 非法值：拒收带指引，不落账不通知（verifying 卡与已落定卡同口径）', async () => {
+  // verifying 卡：缺 verdict
+  const b1 = mkBoard([mkTask({ id: 'k1', status: 'verifying' })])
+  const h1 = mkHarness(b1)
+  const r1 = await h1.tools['board_verdict'].execute({ taskId: 'k1', summary: '全过' }, {})
+  assert.equal(r1.ok, false)
+  assert.match(r1.error, /verdict 必须是 approved 或 rejected（收到：undefined），请带正确字段重调/)
+  assert.equal(b1.tasks[0].status, 'verifying', '状态不动')
+  assert.equal(b1.tasks[0].verification, undefined, '零落账：无 verification')
+  assert.equal(b1.tasks[0].lateVerdict, undefined, '零落账：无 lateVerdict')
+  // 已落定卡：非法值 verdict → 同样拒收（迟到分支也被闸）
+  const b2 = mkBoard([mkTask({ id: 'k2', status: 'resolved', resolvedAt: '2026-01-01T00:01:00Z' })])
+  const h2 = mkHarness(b2)
+  const r2 = await h2.tools['board_verdict'].execute({ taskId: 'k2', verdict: 'pass', summary: '全过' }, {})
+  assert.equal(r2.ok, false)
+  assert.match(r2.error, /verdict 必须是 approved 或 rejected（收到：pass）/)
+  assert.equal(b2.tasks[0].lateVerdict, undefined, '零落账：非法 verdict 不落 lateVerdict')
+  assert.equal(b2.tasks[0].verification, undefined, '零落账：不补建 verification')
+  assert.deepEqual(h2.calls.lateRejects, [], '零通知：无迟到驳回')
+  assert.deepEqual(h2.calls.lateApproves, [], '零通知：无迟到复核')
+  assert.equal(h2.state.poolHealth[FULL_SID], undefined, '零通知：去重指纹也未写')
+  // 纯函数闸：lateVerdictApply 非法 verdict 直返 invalid，一字不落
+  const t3 = mkTask({ id: 'k3', status: 'resolved' })
+  const r3 = core.lateVerdictApply(t3, undefined, 's', 'c', null, 'at', 'by', true)
+  assert.equal(r3.invalid, true); assert.match(r3.error, /收到：undefined/)
+  assert.equal(t3.lateVerdict, undefined); assert.equal(t3.verification, undefined)
+  // 人工通道不受此限：task_verify 正常走（schema 枚举之外的运行时不拦主窗口）
+  const b4 = mkBoard([mkTask({ id: 'k4', status: 'verifying' })])
+  const h4 = mkHarness(b4)
+  const r4 = await h4.tools['task_verify'].execute({ taskId: 'k4', verdict: 'approved' }, {})
+  assert.equal(r4.ok, true); assert.equal(b4.tasks[0].status, 'resolved')
+})
+
+// ===== ② approved 迟到：notice 级「✅ 迟到复核」通知，非 err 级「🚨 迟到驳回」=====
+test('② approved 迟到：通知走 notifyLateApprove（✅ 迟到复核），不触 notifyLateReject，无 lateRejectNote', async () => {
+  const board = mkBoard([mkTask({ id: 'a1', status: 'resolved', resolvedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkHarness(board)
+  const r = await h.tools['board_verdict'].execute({ taskId: 'a1', verdict: 'approved', summary: '复跑全过', checks: '## 核对项\n- ok' }, {})
+  assert.equal(r.ok, true); assert.equal(r.late, true); assert.equal(r.lateRejected, false)
+  assert.equal(board.tasks[0].lateVerdict.verdict, 'approved')
+  assert.deepEqual(h.calls.lateApproves, ['a1'], 'approved 迟到 → ✅ 迟到复核通知')
+  assert.deepEqual(h.calls.lateRejects, [], 'approved 迟到绝不触 🚨 迟到驳回')
+  assert.equal(h.state.poolHealth[FULL_SID].lateRejectNote, undefined, 'health banner 不为 approved 亮')
+  // notify 本体文案：✅ 迟到复核 · 维持原判（全过追认），非 err 措辞
+  const sent = []
+  const notify = createNotify({}, {}, { rt: async () => board, rootForSession: () => ({ followup: (m) => sent.push(m) }), withTimeout: (p) => p, isDispatched: () => false })
+  notify.notifyLateApprove(FULL_SID, board.tasks[0])
+  assert.equal(sent.length, 1)
+  const txt = sent[0].content[0].text
+  assert.match(txt, /✅ \[任务看板\] 迟到复核：a1 维持原判（全过追认）/)
+  assert.match(txt, /复跑全过/)
+  assert.ok(!/🚨|迟到驳回/.test(txt), 'approved 通知无 err 级措辞')
+  assert.equal(sent[0].source.summary, '迟到复核: a1')
+})
+
+// ===== ③ 同指纹去重：二次落账零重复通知 =====
+test('③ 同指纹（taskId+by+verdict）二次落账：通知只投一次；不同 verdict 指纹不同 → 各投一次', async () => {
+  const board = mkBoard([mkTask({ id: 'd1', status: 'resolved', resolvedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkHarness(board)
+  await h.tools['board_verdict'].execute({ taskId: 'd1', verdict: 'approved', summary: '第一次' }, {})
+  await h.tools['board_verdict'].execute({ taskId: 'd1', verdict: 'approved', summary: '第二次（同指纹重投）' }, {})
+  await h.tools['board_verdict'].execute({ taskId: 'd1', verdict: 'approved', summary: '第三次（同指纹重投）' }, {})
+  assert.deepEqual(h.calls.lateApproves, ['d1'], '同指纹三次落账只投一次通知')
+  assert.equal(h.state.poolHealth[FULL_SID].lastLateNotice, 'd1|verifier-child-1|approved', '指纹 = taskId+by+verdict')
+  // 指纹变（verdict 翻驳回）→ 新通知照投（reject 通道）
+  await h.tools['board_verdict'].execute({ taskId: 'd1', verdict: 'rejected', summary: '翻驳回' }, {})
+  assert.deepEqual(h.calls.lateRejects, ['d1'], '指纹不同 → rejected 通知照投')
+  // 驳回同指纹重投 → 也去重
+  await h.tools['board_verdict'].execute({ taskId: 'd1', verdict: 'rejected', summary: '驳回重投' }, {})
+  assert.deepEqual(h.calls.lateRejects, ['d1'], 'rejected 同指纹重投零重复')
+})
+
+// ===== ④ rejected 迟到不回归：维持 err「🚨 迟到驳回」+ lateRejectNote =====
+test('④ rejected 迟到（卡已 approved）：维持 err 级「🚨 迟到驳回」通知 + healthHint 不回归', async () => {
+  const board = mkBoard([mkTask({ id: 'r1', status: 'resolved', resolvedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkHarness(board)
+  const r = await h.tools['board_verdict'].execute({ taskId: 'r1', verdict: 'rejected', summary: '单测红', checks: '## 核对项\n- 红' }, {})
+  assert.equal(r.ok, true); assert.equal(r.late, true); assert.equal(r.lateRejected, true)
+  assert.deepEqual(h.calls.lateRejects, ['r1'])
+  assert.deepEqual(h.calls.lateApproves, [], 'rejected 绝不触 ✅ 迟到复核')
+  assert.equal(h.state.poolHealth[FULL_SID].lateRejectNote.taskId, 'r1', 'err banner 数据源照写')
+  // notify 本体文案：🚨 迟到驳回
+  const sent = []
+  const notify = createNotify({}, {}, { rt: async () => board, rootForSession: () => ({ followup: (m) => sent.push(m) }), withTimeout: (p) => p, isDispatched: () => false })
+  notify.notifyLateReject(FULL_SID, board.tasks[0])
+  assert.equal(sent.length, 1)
+  assert.match(sent[0].content[0].text, /🚨 \[任务看板\] 迟到驳回：r1 你批早了但 Verifier 验出红的/)
+})
+
+// ===== ⑤ health banner 只 rejected 亮 =====
+test('⑤ health err banner：lateRejectNote 只在 rejected 路径出现，computeRuntimeHealthHints 如实透出', () => {
+  // 无 lateRejectNote（approved 迟到的盘面）→ 无迟到 banner
+  const b1 = mkBoard([mkTask({ id: 'h1', status: 'resolved', lateVerdict: { verdict: 'approved', by: 'v', at: 'x' } })])
+  const o1 = computeRuntimeHealthHints(b1, { bornAt: Date.now(), lastLateNotice: 'h1|v|approved' }, { capW: 0, alive: false })
+  assert.ok(!o1.hints.some(function (x) { return /迟到/.test(x.text) }), 'approved 迟到盘面零迟到 banner')
+  // 有 lateRejectNote（rejected 迟到）→ err 级 banner
+  const b2 = mkBoard([mkTask({ id: 'h2', status: 'resolved' })])
+  const o2 = computeRuntimeHealthHints(b2, { bornAt: Date.now(), lateRejectNote: { taskId: 'h2', at: Date.now() } }, { capW: 0, alive: false })
+  const hit = o2.hints.find(function (x) { return /迟到驳回/.test(x.text) })
+  assert.ok(hit, 'rejected 迟到 → banner 亮')
+  assert.equal(hit.level, 'err')
+  assert.match(hit.text, /迟到驳回：h2 你批早了但 Verifier 验出红的/)
+})

package/test/runtime-health.test.mjs

@@ -143,6 +143,28 @@ test('组合场景顺序：①冻结 > ②settle > ③幽灵回收', function ()
   assert.equal(r.consumeReapNote, true)
 })
 
+// ===== ⑤b 终止未生效 hint（terminate 假杀根修②，task-mv8jfu1v，事故实证 n-mv8cfndmvfcv）=====
+test('⑤b 终止未生效 hint：terminateFailNote → err 级红条（sticky 不 TTL）；无记录不亮', function () {
+  var now = Date.now()
+  // 无 terminateFailNote → 不亮
+  assert.deepEqual(computeRuntimeHealthHints({ tasks: [] }, { bornAt: now }, { capW: 0, now: now }).hints, [])
+  // 有记录 → err 级 + 🔴 前缀 + 任务/子会话 id + 补刀指引（与 corruptNote/lateRejectNote 同款 sticky：不消费不 TTL）
+  var rt = { bornAt: now, terminateFailNote: { taskId: 'zk1', childId: 'child-zombie', at: now - 60 * 1000 } }
+  var r = computeRuntimeHealthHints({ tasks: [] }, rt, { capW: 0, now: now })
+  assert.equal(r.hints.length, 1)
+  assert.equal(r.hints[0].level, 'err')
+  assert.ok(r.hints[0].text.indexOf('🔴') >= 0)
+  assert.ok(r.hints[0].text.indexOf('终止未生效') >= 0)
+  assert.ok(r.hints[0].text.indexOf('zk1') >= 0)
+  assert.ok(r.hints[0].text.indexOf('child-zombie') >= 0)
+  assert.ok(r.hints[0].text.indexOf('interrupt_agent') >= 0)
+  // sticky：再读仍在（不消费），与 reapNote 的一次性语义相反——事故亮到人来处理
+  var r2 = computeRuntimeHealthHints({ tasks: [] }, rt, { capW: 0, now: now + 60 * 1000 })
+  assert.equal(r2.hints.length, 1)
+  // 缺 taskId 的畸形记录不亮（防御）
+  assert.deepEqual(computeRuntimeHealthHints({ tasks: [] }, { bornAt: now, terminateFailNote: {} }, { capW: 0, now: now }).hints, [])
+})
+
 // ===== ⑥ host 挂点源码断言 =====
 test('⑥ host 挂点源码断言：dispatch 心跳打点 / rpc 接线 / index state 容器', function () {
   var srcDispatch = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')