dsh-agent-board 1.7.8 → 1.8.0

package/test/core.test.mjs

@@ -480,25 +480,54 @@ test('buildVerifierPrompt: 注入交付物 + 验收脚本 + messages', () => {
   assert.match(p, /做完了/); assert.match(p, /npm test/); assert.match(p, /board_verdict/); assert.match(p, /方案B/)
 })
 
-test('buildWorkerPrompt: git 纪律红线（禁还原命令）注入，verifier prompt 不注入（源码断言）', () => {
+test('buildWorkerPrompt: git 纪律红线（禁还原命令 + 精确路径 add）注入，verifier prompt 不注入（源码断言）', () => {
   const t = mkTask({ id: 'g1' })
   const p = core.buildWorkerPrompt(t)
   assert.match(p, /git 纪律红线/)
   assert.match(p, /禁止 git checkout \/ git restore \/ git reset --hard \/ git clean 等还原命令/)
   assert.match(p, /会冲掉并行 Worker 与你自己的未提交在途编辑/)
   assert.match(p, /确实需要干净基线时用 board_report（kind=escalate）上报/)
+  // 精确路径 add 条款（task-mv73ylwe；n-mv6xntg1p6i5 实证：并行 Worker 共享暂存区，宽泛 add 吞并他卡在途编辑）
+  assert.match(p, /提交时只允许精确路径 git add <本卡 touches 声明的文件>/)
+  assert.match(p, /禁止 git add -A \/ git add \. \/ git add 目录/)
+  assert.match(p, /并行 Worker 共享暂存区，宽泛 add 会把别卡在途编辑卷进你的 commit/)
   // verifier prompt 不动
   const pv = core.buildVerifierPrompt(t)
   assert.doesNotMatch(pv, /git 纪律红线/)
   assert.doesNotMatch(pv, /reset --hard/)
+  assert.doesNotMatch(pv, /精确路径 git add/)
+  assert.doesNotMatch(pv, /git add -A/)
   // 源码级：条款只在 buildWorkerPrompt 体内（切片边界到 buildVerifierPrompt 之前），不在 buildVerifierPrompt 体内
   const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
   const wBody = coreSrc.slice(coreSrc.indexOf('export function buildWorkerPrompt'), coreSrc.indexOf('export function buildVerifierPrompt'))
   assert.ok(wBody.length > 500, 'buildWorkerPrompt 切片成功')
   assert.match(wBody, /git 纪律红线/)
   assert.match(wBody, /git reset --hard/)
+  assert.match(wBody, /提交时只允许精确路径 git add/)
+  assert.match(wBody, /禁止 git add -A/)
   const vBody = coreSrc.slice(coreSrc.indexOf('export function buildVerifierPrompt'), coreSrc.indexOf('export function buildHookPrompt'))
   assert.doesNotMatch(vBody, /git 纪律红线/)
+  assert.doesNotMatch(vBody, /精确路径 git add/)
+})
+
+test('buildWorkerPrompt: 大文件交付纪律（write 主体+edit 续块）注入，verifier prompt 不注入（源码断言）', () => {
+  const t = mkTask({ id: 'lf1' })
+  const p = core.buildWorkerPrompt(t)
+  assert.match(p, /大文件交付纪律/)
+  assert.match(p, /单文件交付预估 >8KB（或 spec 含全量文案\/长代码）时，禁止单次 write 写入全量/)
+  assert.match(p, /先 write 落主体骨架，再用 edit 追加续块（每块 ≤4KB）逐块落地/)
+  // verifier prompt 不动（纪律只约束干活的 Worker）
+  const pv = core.buildVerifierPrompt(t)
+  assert.doesNotMatch(pv, /大文件交付纪律/)
+  assert.doesNotMatch(pv, /每块 ≤4KB/)
+  // 源码级：指引段写死在 buildWorkerPrompt 体内（切片边界到 buildVerifierPrompt 之前），不在 buildVerifierPrompt 体内
+  const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
+  const wBody = coreSrc.slice(coreSrc.indexOf('export function buildWorkerPrompt'), coreSrc.indexOf('export function buildVerifierPrompt'))
+  assert.ok(wBody.length > 500, 'buildWorkerPrompt 切片成功')
+  assert.match(wBody, /大文件交付纪律/)
+  assert.match(wBody, /每块 ≤4KB/)
+  const vBody = coreSrc.slice(coreSrc.indexOf('export function buildVerifierPrompt'), coreSrc.indexOf('export function buildHookPrompt'))
+  assert.doesNotMatch(vBody, /大文件交付纪律/)
 })
 
 // ===== 预研上下文段（瘦身分离形态，task-muvjs392）：笔记全文 + 文件清单，不含文件内容本体 =====
@@ -838,6 +867,29 @@ test('pickDispatch: frozen（裁决挂起冻结）不参与任何自动派发',
   assert.deepEqual(r2.verifs.map(t => t.id).sort(), ['fv', 'nv'])
 })
 
+// ===== 容器卡结构性排除（epic 占 worker 槽根修，用户实证：maxWorkers=3 时一张 =====
+// pipeline=full 的 epic 被派出占槽、已就绪任务空等——此前只靠 pipeline=direct 口头约定）=====
+test('pickDispatch: 有子任务的容器卡（epic）结构性不进派发候选，与 pipeline 无关', () => {
+  const epi = mkTask({ id: 'epic', pipeline: 'full' })        // 手滑建 full 档 epic（缺省管线，未传 direct）
+  const c1 = mkTask({ id: 'c1', parentId: 'epic' })
+  const solo = mkTask({ id: 'solo' })                          // 无子任务普通卡照常派发（防回归）
+  const r = core.pickDispatch(mkBoard([epi, c1, solo]), 5, 0, null)
+  assert.deepEqual(r.pendings.map(t => t.id).sort(), ['c1', 'solo']) // epic 被排除，子任务与普卡照派
+  // 子任务口径含已归档（与 childStats 同源：parentId 仍指向即算容器）——全归档的 epic 也不复活进池
+  const e2 = mkTask({ id: 'e2', pipeline: 'full' })
+  const k1 = mkTask({ id: 'k1', parentId: 'e2', status: 'archived' })
+  assert.deepEqual(core.pickDispatch(mkBoard([e2, k1]), 5, 0, null).pendings.map(t => t.id), [])
+})
+
+test('pickDispatch: 容器卡排除只挡 Worker 派发——epic 收口转 verifying 后 Verifier 派发不受影响', () => {
+  // 既有正确行为：子任务全了结后 epic 转 verifying，派 Verifier 验收是真跑（verifs 分支不动）
+  const epi = mkTask({ id: 'epic', status: 'verifying', pipeline: 'full' })
+  const c1 = mkTask({ id: 'c1', parentId: 'epic', status: 'resolved' })
+  const c2 = mkTask({ id: 'c2', parentId: 'epic', status: 'archived' })
+  const r = core.pickDispatch(mkBoard([epi, c1, c2]), 0, 5, null)
+  assert.deepEqual(r.verifs.map(t => t.id), ['epic'])
+})
+
 // ===== touches 文件级排他：glob 最小匹配器 =====
 test('patOverlap: 完全相同路径冲突 + 归一化（\\ → /、去 ./ 前缀与尾 /）', () => {
   assert.equal(core.patOverlap('src/a.js', 'src/a.js'), true)
@@ -2101,9 +2153,10 @@ test('Token 区统计范围接线：get-tasks 接 range 透传 + fetchTasks 带
   // host：get-tasks 把 args.range 透传给聚合（过滤在 host 做——run 级数据只在 host）
   assert.match(host, /aggregateUsageSummary\(d\.tasks, args && args\.range\)/)
   assert.match(host, /runs\[i\]\.usage/)                        // run 级留账（范围过滤的数据源，先于本次改动已在）
-  // client：轮询带上当前统计范围；空范围不传 field（老 host 调用形态逐字不变）
+  // client：轮询带上当前统计范围；空范围传 {} 占位（rpc 助手 args||{} 归一，host 只读 range 字段，
+  // 与老 host 调用形态等价；task-mv492for 起 {} 上再挂 ifHash 做条件请求）
   assert.match(cli, /var rgSend = activeRange\(\)/)
-  assert.match(cli, /var rpcArgs = \(rgSend\.from \|\| rgSend\.to\) \? \{ range: rgSend \} : undefined/)
+  assert.match(cli, /var rpcArgs = \(rgSend\.from \|\| rgSend\.to\) \? \{ range: rgSend \} : \{\}/)
   assert.match(cli, /rpc\('get-tasks', rpcArgs\)/)
   // 范围守卫：响应回来时范围已变则丢弃旧范围的聚合，不覆盖新范围的值
   assert.match(cli, /if \(rgKey === \(rgNow\.from \+ '~' \+ rgNow\.to\)\) state\.usageSummary = \(d && d\.usageSummary\) \|\| null/)
@@ -2747,6 +2800,7 @@ test('README 双份：运行区子会话 id 归属标注 + git 纪律红线各
   assert.equal(r1, r2, 'README 双份必须逐字一致（npm run sync-readme）')
   assert.ok(r1.indexOf('对应子代理列表同名条目') >= 0, 'README 缺运行区子会话 id 归属标注说明')
   assert.ok(r1.indexOf('git 纪律红线') >= 0, 'README 缺 git 纪律红线说明')
+  assert.ok(r1.indexOf('git add -A') >= 0, 'README 缺精确路径 add 条款说明')
 })
 
 // ===== 归档 tab 数据源口径（反馈 n-muyg3e0m9z7i）：归档 tab 空 vs 仪表盘 68 根修 =====
@@ -4226,6 +4280,49 @@ test('task_cancel GUI 按钮门禁：canCancel 三态 + 详情页按钮接线 +
   }
 })
 
+// ===== 详情面板「取消」消歧（task-mv493xjs，巡检实证 n-mv2turadjv63 误触 task_cancel）=====
+test('详情面板消歧：「取消」改名「取消任务」+ 危险操作区视觉分层 + ✕ 关闭钮（源码+产物双锁）', () => {
+  const tdsrc = readFileSync(new URL('../lib/client/task-detail.js', import.meta.url), 'utf8')
+  const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+  // ① 新文案源码锁定：按钮标签为「取消任务」，不再出现裸「取消」按钮标签（ic('ban', 10), '取消'）
+  assert.ok(tdsrc.indexOf("ic('ban', 10), '取消任务'") >= 0, 'task-detail.js 缺「取消任务」新文案')
+  assert.ok(tdsrc.indexOf("ic('ban', 10), '取消')") < 0, 'task-detail.js 仍残留裸「取消」按钮标签')
+  // ② 视觉分层：破坏性按钮独立成区（虚线分隔 + 「危险操作」前缀 + aria-label），与表单按钮组拉开
+  assert.ok(tdsrc.indexOf("'aria-label': '危险操作'") >= 0, 'task-detail.js 缺危险操作区分组')
+  assert.ok(tdsrc.indexOf("borderTop: '1px dashed ' + C.err") >= 0, 'task-detail.js 缺危险区顶部分隔线')
+  assert.ok(tdsrc.indexOf('危险操作') >= 0, 'task-detail.js 缺「危险操作」前缀标签')
+  // ④ ✕ 关闭钮：详情头部右上显性关闭（与「← 返回看板」同行走 state.detailId = null）
+  assert.ok(tdsrc.indexOf("title: '关闭详情面板（返回看板）'") >= 0, 'task-detail.js 缺 ✕ 关闭钮')
+  // ③ 产物重组装：新文案/分层/关闭钮全部进 lib/client.js
+  for (const m of ["ic('ban', 10), '取消任务'", '危险操作', "title: '关闭详情面板（返回看板）'"]) {
+    assert.ok(built.indexOf(m) >= 0, 'client.js 缺标记：' + m)
+  }
+})
+
+// ===== GUI RPC 操作者回退（task-mv493xjs，巡检次生观察①：流转轨迹 actor 显示 unknown）=====
+// 面板 HTTP RPC 无 agent 调用栈 → getActorId() 落 'unknown'；rpcActor 回退 args 自带 sessionId。
+test('GUI RPC actor 回退：getActorId=unknown 时流转历史 actor 落会话身份（不再 unknown）', async () => {
+  const t = mkTask({ id: 'g1', status: 'pending' })
+  const board = mkBoard([t])
+  const h = mkRpcHandlers(board, { getActorId: () => 'unknown' })
+  const r = await h['cancel-task']({ taskId: 'g1', reason: 'GUI 误建' })
+  assert.equal(r.ok, true)
+  // actor 不再是 unknown，而是 rpcSessionId(args) 归一出的会话 id（测试桩=FULL_SID）
+  assert.ok(t.history.some(function (x) { return x.to === 'cancelled' && x.actor === FULL_SID }), 'history actor 未回退到会话 id')
+  assert.ok(!t.history.some(function (x) { return x.actor === 'unknown' }), 'history 仍出现 unknown actor')
+  // 正对照：有真实 initiator 时不回退（保持 actor 原值）
+  const t2 = mkTask({ id: 'g2', status: 'pending' })
+  const h2 = mkRpcHandlers(mkBoard([t2]))
+  await h2['cancel-task']({ taskId: 'g2' })
+  assert.ok(t2.history.some(function (x) { return x.to === 'cancelled' && x.actor === 'tester' }), '有 initiator 时 actor 被意外改写')
+  // 归档通道同口径（GUI 高频操作）
+  const t3 = mkTask({ id: 'g3', status: 'resolved' })
+  const h3 = mkRpcHandlers(mkBoard([t3]), { getActorId: () => 'unknown' })
+  const r3 = await h3['archive-task']({ taskId: 'g3' })
+  assert.equal(r3.ok, true)
+  assert.ok(t3.history.some(function (x) { return x.to === 'archived' && x.actor === FULL_SID }), '归档 history actor 未回退到会话 id')
+})
+
 // ===== 反馈修复（task-mux3uvx3，反馈 n-muw706h1uymy）：归档路径触发父卡收口 + task_resolve 守卫对齐 =====
 test('归档双通道触发父卡自动收口：archive-task RPC 与 task_archive 工具同一 archiveApply 口径', async () => {
   // RPC 通道：归档末子卡 → 父卡 in-progress → verifying
@@ -4304,9 +4401,10 @@ test('反馈修复接线断言：index.mjs 注入 hasActiveRun + get-tasks 附 t
   const rpcSrc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
   assert.equal((rpcSrc.match(/archiveErr\(sid, t\)/g) || []).length, 3)
   // kernel：hash 短路分支存在（hash 相同跳过 tasks 赋值 + notify；老 host 无 hash 恒视为变化）
+  // task-mv492for：tasksChanged 叠加 unchanged 闸门（host 条件响应不含 tasks 时绝不清空列表）
   const ksrc = readFileSync(new URL('../lib/client/kernel.js', import.meta.url), 'utf8')
   assert.match(ksrc, /var newHash = \(d && d\.tasksHash\) \|\| ''/)
-  assert.match(ksrc, /var tasksChanged = !newHash \|\| newHash !== state\.tasksHash/)
+  assert.match(ksrc, /var tasksChanged = !unchanged && \(!newHash \|\| newHash !== state\.tasksHash\)/)
   assert.match(ksrc, /if \(tasksChanged\) \{[\s\S]*?notify\(\)/)
 })
 
@@ -4488,13 +4586,37 @@ test('isRoot 持久语义：host 侧改读 parentSession（根=无父），防
   const rpcSrc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
   // isRoot 持久判定入口：根会话=无父，不再读活跃 roots() 集
   assert.match(rpcSrc, /async function isRootPersistent\(sid\)/)
-  assert.match(rpcSrc, /snap\.header\) return !snap\.header\.parentSession/)
+  // task-mv59nn9m：判据改用 delegationDepth——无父=根，或 parentSession 有值但 delegationDepth===0（fork/seed 会话）也认根
+  assert.match(rpcSrc, /return !hh\.parentSession \|\| \(typeof hh\.delegationDepth === 'number' && hh\.delegationDepth === 0\)/)
   assert.match(rpcSrc, /d\.isRoot = await isRootPersistent\(sid\)/)
   // 指针注释：防抖仍在客户端 kernel.js applyIsRoot，曾确认 true 需连续 3 次 false 才收
   assert.match(rpcSrc, /防抖仍在客户端：kernel\.js applyIsRoot/)
   assert.match(rpcSrc, /曾确认 true 的会话需连续 3 次/)
 })
 
+// ===== fork 会话认根（task-mv59nn9m，用户报障：ontology_ai「本体数据平台开发」fork 会话看板不可见）=====
+// 根因：isRootPersistent stat 主源旧判据 `!header.parentSession` 把 fork/seed 会话
+//（v3→v4 迁移产物：parentSession 有值 + delegationDepth:0 + isSeeded:true）误判非根 → isRoot:false → 看板入口消失。
+// 修法：判据改 `!h.parentSession || (typeof h.delegationDepth==='number' && h.delegationDepth===0)`；
+// delegationDepth 缺省（v3 时代老会话无此字段）且有 parentSession 时维持非根保守判定（兼容 v3 时代子代理）。
+test('isRootPersistent 判据 delegationDepth（行为级）：fork 认根 / 子代理非根 / 老形态保守 / 真根不变', async () => {
+  function mkPersistCtx(header) {
+    return { get: function (name) { if (name === 'sessionPersistence') return { stat: async function () { return { header: header } } }; return undefined } }
+  }
+  // ① fork/seed 头（parentSession 有 + delegationDepth 0）→ 根（本卡修复目标）
+  const h1 = mkRpcHandlers(mkBoard([]), null, mkPersistCtx({ parentSession: 'session-parent', delegationDepth: 0 }))
+  assert.equal((await h1['get-tasks']({})).isRoot, true)
+  // ② 真子代理头（parentSession 有 + delegationDepth 1）→ 非根
+  const h2 = mkRpcHandlers(mkBoard([]), null, mkPersistCtx({ parentSession: 'session-parent', delegationDepth: 1 }))
+  assert.equal((await h2['get-tasks']({})).isRoot, false)
+  // ③ 老形态头（parentSession 有 + delegationDepth 缺省，v3 时代会话）→ 非根（保守判定不放行）
+  const h3 = mkRpcHandlers(mkBoard([]), null, mkPersistCtx({ parentSession: 'session-parent' }))
+  assert.equal((await h3['get-tasks']({})).isRoot, false)
+  // ④ 真根（无 parentSession）→ 根
+  const h4 = mkRpcHandlers(mkBoard([]), null, mkPersistCtx({}))
+  assert.equal((await h4['get-tasks']({})).isRoot, true)
+})
+
 // ===== 史诗 hooks UI（task-muuw56yf）：卡片相位徽章 + 详情页 hooks 编辑区 =====
 // 依赖卡 task-muuw4ov7 落地的真实字段契约（本文件上方 hooks 测试段即其口径）：
 //   epic.hooks = { pre: { enabled, prompt, state, runId, pending? }, post: 同构 }；state ∈ idle|running|done|failed；
@@ -5092,6 +5214,82 @@ test('卡3②③：重启 reconcile——存活的续跑 Worker 被找回重挂
   assert.equal(h.runs['k1'], before)
 })
 
+// ===== 僵尸 run 留档清扫（task-mv22z61v）：落定卡 running 无 endedAt 留档关账 + 清卡面认领位 =====
+test('僵尸 run 留档清扫：落定卡 running 无 endedAt 留档被关账+清位；在飞卡/活跃 rec 不扫；二次运行零改动', async () => {
+  const nowIso = new Date().toISOString()
+  // ① 僵尸 verifier 留档：resolved 卡 + verifierRun 残留指向死会话 + runs[] 里 verifier:running 无 endedAt
+  const zv = mkTask({ id: 'zv', title: '僵尸 verifier 卡', status: 'resolved', verifierRun: 'v-dead', verifierRunAt: '2026-01-01T00:00:00Z',
+    runs: [{ role: 'verifier', id: 'v-dead', at: '2026-01-01T00:00:00Z', model: '', outcome: 'running' }] })
+  // ② 僵尸 worker 留档：cancelled 卡 + claimedBy 残留指向死会话
+  const zw = mkTask({ id: 'zw', title: '僵尸 worker 卡', status: 'cancelled', claimedBy: 'w-dead', claimedAt: '2026-01-01T00:00:00Z',
+    runs: [{ role: 'worker', id: 'w-dead', at: '2026-01-01T00:00:00Z', model: '', outcome: 'running' }] })
+  // ③ 已关账留档：outcome 已落定 + endedAt，非 running 条目不该被碰（不误扫非 running 留档）
+  const zc = mkTask({ id: 'zc', title: '已关账卡', status: 'resolved',
+    runs: [{ role: 'worker', id: 'w-ok', at: '2026-01-01T00:00:00Z', model: '', outcome: 'completed', endedAt: '2026-01-01T00:05:00Z' }] })
+  // ④ 在飞卡（in-progress）：running 留档是 reconcile/结算通道辖区，绝不误扫（断言②）
+  const inflight = mkTask({ id: 'fly', title: '在飞卡', status: 'in-progress', claimedBy: 'w-alive', claimedAt: nowIso,
+    runs: [{ role: 'worker', id: 'w-alive', at: nowIso, model: '', outcome: 'running', continuable: true }] })
+  // ⑤ 在飞卡（verifying）+ 活跃 rec：双重护栏——status 非落定 + 内存活跃表里还活着，都该跳过（断言② + 无活跃 rec 才扫）
+  const vfy = mkTask({ id: 'vfy', title: '验收中卡', status: 'verifying', verifierRun: 'v-alive', verifierRunAt: nowIso,
+    runs: [{ role: 'verifier', id: 'v-alive', at: nowIso, model: '', outcome: 'running' }] })
+  const board = mkBoard([zv, zw, zc, inflight, vfy])
+  const h = mkUsageDispatch(board)
+  h.runs['vfy'] = { id: 'v-alive', role: 'verifier', taskId: 'vfy', startedAt: Date.now(), model: '', settled: false }
+  await h.dispatch.poolCycle(FULL_SID)
+  // ① 僵尸 verifier 留档：关账（stale-closed + endedAt + note）+ 清 verifierRun 位 + 留一行 history
+  assert.equal(zv.runs[0].outcome, 'stale-closed')
+  assert.ok(zv.runs[0].endedAt, '僵尸 verifier 留档要带 endedAt')
+  assert.equal(zv.runs[0].note, 'host 重启僵尸留档清扫')
+  assert.equal(zv.verifierRun, null)
+  assert.equal('verifierRunAt' in zv, false)
+  assert.equal(zv.history.filter(function (x) { return /僵尸 run 留档已关账/.test(x.note || '') }).length, 1)
+  // ② 僵尸 worker 留档：关账 + 清 claimedBy 位
+  assert.equal(zw.runs[0].outcome, 'stale-closed')
+  assert.ok(zw.runs[0].endedAt)
+  assert.equal(zw.runs[0].note, 'host 重启僵尸留档清扫')
+  assert.equal(zw.claimedBy, null)
+  assert.equal(zw.claimedAt, null)
+  // ③ 已关账留档零改动
+  assert.equal(zc.runs[0].outcome, 'completed')
+  assert.equal(zc.runs[0].endedAt, '2026-01-01T00:05:00Z')
+  assert.equal(zc.runs[0].note, undefined)
+  // ④⑤ 在飞卡 running 留档零改动（断言②：in-progress/verifying 都不扫）
+  assert.equal(inflight.runs[0].outcome, 'running')
+  assert.equal(inflight.runs[0].endedAt, undefined)
+  assert.equal(inflight.claimedBy, 'w-alive')
+  assert.equal(vfy.runs[0].outcome, 'running')
+  assert.equal(vfy.runs[0].endedAt, undefined)
+  assert.equal(vfy.verifierRun, 'v-alive')
+  // ⑤ 幂等：二次运行零改动（关账后 outcome!=running，不再新增 history 行 / 不再刷新 endedAt）
+  const zvEndedAt = zv.runs[0].endedAt
+  const zwEndedAt = zw.runs[0].endedAt
+  const zvHistoryLen = zv.history.length
+  const zwHistoryLen = zw.history.length
+  await h.dispatch.poolCycle(FULL_SID)
+  assert.equal(zv.runs[0].outcome, 'stale-closed')
+  assert.equal(zv.runs[0].endedAt, zvEndedAt)
+  assert.equal(zv.history.length, zvHistoryLen)
+  assert.equal(zw.runs[0].outcome, 'stale-closed')
+  assert.equal(zw.runs[0].endedAt, zwEndedAt)
+  assert.equal(zw.history.length, zwHistoryLen)
+})
+
+test('僵尸 run 留档清扫接线（源码级）：sweepZombieRuns 定义 + poolCycle 挂点 + 只清扫落定卡门禁', () => {
+  const dsp = readFileSync(new URL('../lib/dispatch.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/) // 无改动不写盘（安静板不因清扫产生心跳写盘）
+  // ② poolCycle 挂点：reconcile 之后、幽灵回收之前（落定卡僵尸留档 reconcile/reap 都管不到，须在空闲快进前兜到）
+  assert.match(dsp, /try \{ await 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')
   const usageSrc = readFileSync(new URL('../lib/usage.mjs', import.meta.url), 'utf8')
@@ -5250,8 +5448,9 @@ test('fetchTasks 设置开关权威纠偏：hash 不变时配置变化补 notify
   const iNotify = src.indexOf('if (cfgDelta || usageDelta) notify()')
   const iEsc = src.indexOf('if (tasksChanged) {\n          var newEsc')
   assert.ok(iDelta < iNotify && iEsc > iNotify, '补 notify 必须在配置赋值之后、escalation 分支之前')
-  // ④ 既有渲染节约（tasksHash 短路）逐字保持——本次只加不删
-  assert.match(src, /var tasksChanged = !newHash \|\| newHash !== state\.tasksHash/)
+  // ④ 既有渲染节约（tasksHash 短路）结构保持——task-mv492for 起 tasksChanged 叠加 unchanged 闸门
+  // （host 条件响应 unchanged:true 不含 tasks 全量时保留 state.tasks），hash 比对短路语义不变
+  assert.match(src, /var tasksChanged = !unchanged && \(!newHash \|\| newHash !== state\.tasksHash\)/)
   assert.match(src, /if \(tasksChanged\) \{\s*\n\s*state\.tasksHash = newHash\s*\n\s*state\.tasks = \(d && d\.tasks\) \|\| \[\]\s*\n\s*\}/)
   // ⑤ 产物接线：client.js 为拼装产物，真源改动必须已重建（产物与源一致由 build-client --check 兜底）
   const cli = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
@@ -5551,6 +5750,7 @@ test('高优干预①（continuable）：rec 无 run 也走宿主投递——hos
   assert.equal(r.ok, true)
   assert.equal(r.delivered, true, 'continuable rec 干预必须真的送达（旧实现整段被跳过 → delivered 恒 false）')
   assert.equal(r.channel, 'steer', 'e2e 断言口径不变：channel 必须仍是 steer')
+  assert.equal(r.state, 'delivered', '实时送达：state=delivered（task-mv6c7cbo 返回体新字段）')
   assert.equal(hostCalls.length, 1)
   assert.deepEqual(sent, [], 'host-protocol 可用时不再重复走 sendMessage（一次干预只投一次）')
   assert.equal(hostCalls[0].p, parent)                  // 授权者 = 活的直接父 Agent
@@ -5597,6 +5797,7 @@ test('高优干预②（一次性 rec 逐字不变）：agent.steer 优先、ste
   board.tasks.push(idle)
   r = await handlers['intervene-agent']({ taskId: 'iv8', message: '无 run 的干预' })
   assert.equal(r.delivered, false); assert.equal(r.channel, '')
+  assert.equal(r.state, 'no-run', '真无 run：state=no-run（GUI 提示色区分字段，task-mv6c7cbo）')
   assert.match(idle.history[idle.history.length - 1].note, /^高优干预: 无 run 的干预（无活跃 run，随下次派发注入）$/)
 })
 
@@ -5656,6 +5857,57 @@ test('高优干预③（continuable 回退链）：host 符号不可用 → send
   assert.equal(t6.messages.filter((m) => m.kind === 'intervention').length, 1)
 })
 
+// ===== 送达提示两态细分（task-mv6c7cbo，实证 n-mv65bhk0mg5w：run 已结算 rec 摘除、claimedBy 仍在续跑窗口，
+//       旧文案「无活跃 run」技术为真但对用户误导——干预实际随续跑注入）=====
+test('高优干预⑤（续跑窗口细分）：无 rec 但续跑资格/认领位还在 → 文案「随续跑注入」+ state=resume-pending', async () => {
+  // 形态 A：run 刚结算留档 incomplete+continuable（resumeTarget 命中），claimedBy 仍指已结算子会话（续跑窗口原形）
+  const resumeTask = mkTask({
+    id: 'iv9', title: '续跑窗口卡', status: 'in-progress', claimedBy: 'child-done',
+    runs: [{ role: 'worker', id: 'child-done', at: '2026-01-01T00:00:00Z', model: '', outcome: 'incomplete', continuable: true }],
+  })
+  // 形态 B：认领位还在但无任何 runs 留档（resumeTarget 空，纯 claimedBy 重排窗口）
+  const claimed = mkTask({ id: 'iv10', title: '重排窗口卡', status: 'in-progress', claimedBy: 'child-x' })
+  const board = mkBoard([resumeTask, claimed])
+  // resumeTarget 走真实函数（与 index.mjs 生产接线同径：从 createDispatch 返回体取出注入 deps）
+  const dsp = mkContinuableDispatch(mkBoard([]))
+  const handlers = mkRpcHandlers(board, { runsFor: () => ({}), resumeTarget: dsp.dispatch.resumeTarget })
+  // A：resumeTarget 命中 → 续跑窗口文案 + state，且不得再出现失真原文「无活跃 run」
+  let r = await handlers['intervene-agent']({ taskId: 'iv9', message: '窗口期干预A' })
+  assert.equal(r.ok, true); assert.equal(r.delivered, false); assert.equal(r.channel, '')
+  assert.equal(r.state, 'resume-pending')
+  const noteA = resumeTask.history[resumeTask.history.length - 1].note
+  assert.match(noteA, /^高优干预: 窗口期干预A（run 刚结算\/续跑窗口，干预将随续跑注入）$/)
+  assert.ok(!/无活跃 run/.test(noteA), '续跑窗口不得再报「无活跃 run」（task-mv6c7cbo 修复的失真原文）: ' + noteA)
+  // 干预原文落 messages——续跑指令经 buildMessages 原文带上（「随续跑注入」语义成立的依据）
+  assert.equal(resumeTask.messages.filter((m) => m.kind === 'intervention').length, 1)
+  assert.equal(resumeTask.messages.filter((m) => m.kind === 'intervention')[0].text, '窗口期干预A')
+  // B：claimedBy 窗口（resumeTarget 空）→ 同一文案与 state
+  r = await handlers['intervene-agent']({ taskId: 'iv10', message: '窗口期干预B' })
+  assert.equal(r.delivered, false); assert.equal(r.state, 'resume-pending')
+  assert.match(claimed.history[claimed.history.length - 1].note, /（run 刚结算\/续跑窗口，干预将随续跑注入）$/)
+  // C：deps 未注入 resumeTarget（老宿主/测试桩降级）→ claimedBy 窗口仍命中，语义只降不炸
+  const handlers2 = mkRpcHandlers(board, { runsFor: () => ({}) })
+  r = await handlers2['intervene-agent']({ taskId: 'iv10', message: '窗口期干预C' })
+  assert.equal(r.state, 'resume-pending')
+  assert.match(claimed.history[claimed.history.length - 1].note, /干预将随续跑注入/)
+})
+
+// ===== 两态细分接线（源码级）：文案/state 字段/透出/接线不被将来改动悄悄抹掉 =====
+test('高优干预⑥（源码级）：续跑窗口两态文案 + state 字段 + resumeTarget 透出与 rpc 接线在位', () => {
+  const rpcSrc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
+  const dsp = readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  const idx = readFileSync(new URL('../index.mjs', import.meta.url), 'utf8')
+  assert.match(rpcSrc, /（run 刚结算\/续跑窗口，干预将随续跑注入）/)                 // 续跑窗口文案
+  assert.match(rpcSrc, /（无活跃 run，随下次派发注入）/)                              // 真无 run 文案不回归
+  assert.match(rpcSrc, /state = 'resume-pending'/)
+  assert.match(rpcSrc, /state = 'no-run'/)
+  assert.match(rpcSrc, /return \{ ok: true, delivered: delivered, channel: channel, state: state \}/) // 返回体带 state
+  assert.match(rpcSrc, /resumeTarget\(t\) !== '' \|\| t\.claimedBy/)               // 两态判据（锁内新鲜快照）
+  assert.match(rpcSrc, /var resumeTarget = typeof deps\.resumeTarget === 'function'/) // 缺 dep 降级不炸
+  assert.match(dsp, /resumeTarget: resumeTarget/)                                  // dispatch 返回体透出
+  assert.match(idx, /resumeTarget: dispatch\.resumeTarget/)                        // 生产接线
+})
+
 // ===== Bug B ④（源码级）：投递点接线不被将来改动悄悄抹掉 =====
 test('高优干预④（源码级）：continuable 投递点 = host-protocol 符号键 + sendMessage 回退，且分路在 rec.continuable 上', () => {
   const rpcSrc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
@@ -5769,3 +6021,154 @@ test('巡检三连②-③：归档「恢复待办」confirm 门禁（list 不弹
   const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
   assert.match(built, /window\.confirm\('恢复待办后将按当前工作模式立即重新派发，消耗一轮 Worker\+Verifier token。继续/)
 })
+
+// ===== set-board-config 模型字段校验（task-mv73ym2k，实证 n-mv6ezj6vary4）=====
+// ① 非法 id 拒写 + 报错带合法清单 ② 合法 id 通过 ③ 空串清除放行 ④ llm 缺失降级放行
+// ⑤ 熔断通知分态：UNKNOWN_MODEL → 「配置非法（不在可用清单）」≠「验收连续失败」
+function mkLlmCtx(modelsByProvider) {
+  // modelsByProvider: { providerId: [{id, name}] }——对齐宿主 llm 服务契约（listProviders/listModels）
+  return {
+    get: function (name) {
+      if (name !== 'llm') return null
+      return {
+        listProviders: function () { return Object.keys(modelsByProvider).map(function (id) { return { id: id, name: id } }) },
+        listModels: async function (p) { return modelsByProvider[p] || [] },
+      }
+    },
+  }
+}
+const MOCK_MODELS = { deepseek: [{ id: 'deepseek-chat', name: 'DeepSeek Chat' }, { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner' }], kimi: [{ id: 'kimi-k2', name: 'Kimi K2' }] }
+
+test('set-board-config 模型校验①：非法 id 拒写 + 报错带合法清单，看板不落脏值', async () => {
+  const board = mkBoard([])
+  const h = mkRpcHandlers(board, {}, mkLlmCtx(MOCK_MODELS))
+  // 实证原形：显示名「kimi/kimi-k3」抄成 id（合法的是 kimi/kimi-k2）
+  const r = await h['set-board-config']({ key: 'verifierModel', value: 'kimi/kimi-k3' })
+  assert.equal(r.ok, false)
+  assert.match(r.error, /非法模型 id: kimi\/kimi-k3/)
+  assert.match(r.error, /不在当前网关可用清单/)
+  assert.match(r.error, /合法清单（3 个，示前 3 个）/) // 总数 + 截断计数透出
+  assert.match(r.error, /deepseek\/deepseek-chat/) // 清单样例带合法 id
+  assert.match(r.error, /list-models/) // 指引完整清单入口
+  assert.equal(board.verifierModel, undefined) // 拒写：看板字段未被污染
+  // workerModel 同款门禁
+  const r2 = await h['set-board-config']({ key: 'workerModel', value: 'openai/gpt-99' })
+  assert.equal(r2.ok, false)
+  assert.match(r2.error, /非法模型 id/)
+  assert.equal(board.workerModel, undefined)
+})
+
+test('set-board-config 模型校验②：合法 id 双字段通过落盘', async () => {
+  const board = mkBoard([])
+  const h = mkRpcHandlers(board, {}, mkLlmCtx(MOCK_MODELS))
+  const r = await h['set-board-config']({ key: 'verifierModel', value: 'kimi/kimi-k2' })
+  assert.equal(r.ok, true)
+  assert.equal(board.verifierModel, 'kimi/kimi-k2')
+  const r2 = await h['set-board-config']({ key: 'workerModel', value: ' deepseek/deepseek-reasoner ' }) // 首尾空格 trim 后命中
+  assert.equal(r2.ok, true)
+  assert.equal(board.workerModel, 'deepseek/deepseek-reasoner')
+})
+
+test('set-board-config 模型校验③：空串/非字符串=清除覆盖，放行不校验', async () => {
+  const board = mkBoard([])
+  board.verifierModel = 'kimi/kimi-k2'
+  const h = mkRpcHandlers(board, {}, mkLlmCtx(MOCK_MODELS))
+  const r = await h['set-board-config']({ key: 'verifierModel', value: '' })
+  assert.equal(r.ok, true)
+  assert.equal(board.verifierModel, '')
+  const r2 = await h['set-board-config']({ key: 'verifierModel', value: undefined })
+  assert.equal(r2.ok, true)
+  assert.equal(board.verifierModel, '')
+  // 非模型键不受枚举影响（无 llm 也照常写）
+  const h2 = mkRpcHandlers(board)
+  const r3 = await h2['set-board-config']({ key: 'maxWorkers', value: 5 })
+  assert.equal(r3.ok, true)
+  assert.equal(board.maxWorkers, 5)
+})
+
+test('set-board-config 模型校验④：llm 服务缺失（老宿主）降级放行，不炸', async () => {
+  const board = mkBoard([])
+  // 显式给「有 get 但 llm 缺席」的老宿主形态（mkRpcHandlers 默认 ctx 无 get 方法，生产 ctx.get 恒存在）
+  const hNoLlm = mkRpcHandlers(board, {}, { get: function () { return null } })
+  const r = await hNoLlm['set-board-config']({ key: 'verifierModel', value: 'whatever/display-name' })
+  assert.equal(r.ok, true) // 降级放行：不校验直接写
+  assert.equal(board.verifierModel, 'whatever/display-name')
+  // list-models 在同形态下报服务不可用（既有契约不变）
+  const lm = await hNoLlm['list-models']({})
+  assert.equal(lm.ok, false)
+  assert.match(lm.error, /llm service unavailable/)
+})
+
+test('set-board-config 模型校验④b：provider 枚举失败不阻塞，其余 provider 清单仍可校验', async () => {
+  const board = mkBoard([])
+  const ctxExtra = {
+    get: function (name) {
+      if (name !== 'llm') return null
+      return {
+        listProviders: function () { return [{ id: 'broken', name: 'B' }, { id: 'kimi', name: 'K' }] },
+        listModels: async function (p) { if (p === 'broken') throw new Error('gateway boom'); return [{ id: 'kimi-k2' }] },
+      }
+    },
+  }
+  const h = mkRpcHandlers(board, {}, ctxExtra)
+  const rBad = await h['set-board-config']({ key: 'workerModel', value: 'broken/any' }) // 枚举失败的 provider 清单缺席 → 拒
+  assert.equal(rBad.ok, false)
+  assert.match(rBad.error, /kimi\/kimi-k2/)
+  const rOk = await h['set-board-config']({ key: 'workerModel', value: 'kimi/kimi-k2' })
+  assert.equal(rOk.ok, true)
+  assert.equal(board.workerModel, 'kimi/kimi-k2')
+})
+
+// 熔断通知分态行为测试 harness：一次性 verifier run 失败，捕获 pushSysNote 文案 + badModels 落账
+async function runVerifierFuseCase(errText) {
+  const t = mkTask({ id: 'v-fuse', title: '待验收卡', status: 'verifying' })
+  const board = mkBoard([t])
+  board.verifierModel = 'kimi/kimi-k3' // 已写入的（非法）模型覆盖 → rec.model 非空才会触发熔断
+  const notes = []
+  const runs = {}
+  const activeRuns = { [FULL_SID]: runs }
+  const badModels = {}
+  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 本身成功（半建会话不存在的问题在 provider 层），run.result 随后以给定错误落定失败
+      start: async () => ({ id: 'run-fuse', result: new Promise(function (res, rej) { setImmediate(function () { rej(new Error(errText)) }) }), dispose: async function () {} }),
+      startContinuable: async () => ({ childId: 'child-x', messageId: 'm1' }),
+    },
+  }
+  const dispatch = createDispatch(ctx, { knownSessions: {}, dispatchedEver: {}, badModels: badModels, teamModeCache: {}, activeRuns: activeRuns }, {
+    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: () => {},
+  })
+  await dispatch.poolCycle(FULL_SID)
+  assert.ok(runs['v-fuse'], 'verifier run 应已登记活跃表')
+  // 等 run.result 拒绝 → settleRun → settleVerifier 链落定
+  const flushN = () => new Promise(r => setImmediate(r))
+  for (var i = 0; i < 8; i++) await flushN()
+  return { notes: notes, badModels: badModels, task: t }
+}
+
+test('模型熔断分态①：UNKNOWN_MODEL → 「配置非法（不在可用清单）」，不误报连续失败', async () => {
+  const r = await runVerifierFuseCase('spawn failed: UNKNOWN_MODEL: kimi/kimi-k3 (model not configured)')
+  assert.equal(r.badModels[FULL_SID + '|kimi/kimi-k3'], true) // 熔断照常落账（下轮回退父级）
+  assert.equal(r.notes.length, 1)
+  assert.match(r.notes[0], /模型 kimi\/kimi-k3 配置非法（不在可用清单），已熔断回退父级模型/)
+  assert.match(r.notes[0], /list-models/) // 指引重配入口
+  assert.ok(!/验收连续失败/.test(r.notes[0]), 'mistake 类不得误报为 quality 类')
+  assert.equal(r.task.verifyRetries, 1) // 重试计数语义不变
+})
+
+test('模型熔断分态②：非 UNKNOWN_MODEL 失败 → 保持「验收连续失败」原文案', async () => {
+  const r = await runVerifierFuseCase('provider timeout after 30s')
+  assert.equal(r.badModels[FULL_SID + '|kimi/kimi-k3'], true)
+  assert.equal(r.notes.length, 1)
+  assert.match(r.notes[0], /模型 kimi\/kimi-k3 验收连续失败，已熔断回退父级模型/)
+  assert.ok(!/配置非法/.test(r.notes[0]))
+})

package/test/helpers/mock-ctx.mjs

@@ -10,7 +10,8 @@
 //   · subagents.startContinuable({...})         → { childId, messageId }（持久子会话，turn 结算走 emitStatus）
 //   · subagents.sendMessage / interrupt / listChildren → 记录器 + 可剧本化
 //   · agents.currentInitiator()/roots()/list()/get()/isOwnedBy() → 按测试剧本返回（缺省单 root，actor=root；env.setRoots 可清空模拟休眠）
-//   · ctx.get('sessionPersistence')             → 持久会话表 stat(id)（env.persistedHeaders 可写 parentSession 模拟子会话/根会话）
+//   · ctx.get('sessionPersistence')             → 持久会话表 stat(id)（env.persistedHeaders 可写 parentSession 模拟子会话/根会话；
+//                                                 env.persistedSizes[id]=N 可让快照带 sizeBytes——cleanup 体积主源断言用）
 //   · tools.register / webServer.register       → 捕获工具表与 RPC 路由（env.rpc 走真 readBody/handler 路径）
 //   · ctx.get('systemPrompt'|'llm')             → 记录器（注册了什么段/查了什么模型都留痕）
 //   · ctx.effect / ctx.on('agent/status')       → 真实执行 + disposer 收口 / 事件捕获与重放
@@ -51,6 +52,7 @@ import { Readable } from 'node:stream'
  * @property {string} actor          currentInitiator 返回值（缺省=root sid；测试可改写模拟子代理身份）
  * @property {(list:Object[])=>void} setRoots  改写活跃 root 集（传 [] 模拟休眠根会话/重建窗口）
  * @property {Object} persistedHeaders  持久会话表 sid → { id, parentSession }（写 parentSession 模拟子会话；缺省根会话 parentSession=undefined）
+ * @property {Object} persistedSizes    快照体积表 sid → sizeBytes 数字（cleanup 体积主源断言用；缺省=快照无 sizeBytes → 目录遍历回退）
  * @property {()=>Object} board      读当前看板文件 JSON（不存在返回 null）
  * @property {(id:string)=>Object|undefined} task  看板里按 id 取任务
  * @property {(fn:Function, label?:string, timeoutMs?:number)=>Promise<any>} waitFor  真实时间轮询直到条件为真（默认 5s 上限）
@@ -194,6 +196,7 @@ export function createMockCtx(opts) {
   var rootsList = [root] // 活跃 root 集（测试可 env.setRoots([]) 清空模拟「休眠根会话」）
   var persistedHeaders = {} // 持久会话表 sid → SessionHeader（测试可写 parentSession 模拟子会话/根会话）
   persistedHeaders[sid] = { id: sid, parentSession: undefined }
+  var persistedSizes = {} // 快照体积表 sid → sizeBytes（task-mv39ag1e：cleanup 体积主源断言用；缺省=快照无 sizeBytes，走目录遍历回退）
   var agents = {
     currentInitiator: function () { return { id: env.actor } },
     roots: function () { return rootsList },
@@ -237,7 +240,8 @@ export function createMockCtx(opts) {
       }
       if (name === 'sessionPersistence') {
         return {
-          stat: async function (id) { var h = persistedHeaders[id]; return h ? { header: h } : undefined },
+          // 快照形态对齐官方 SessionPersistenceSnapshot：sizeBytes 仅当后端能廉价提供时才带（未登记=缺省字段）
+          stat: async function (id) { var h = persistedHeaders[id]; if (!h) return undefined; var snap = { header: h }; if (typeof persistedSizes[id] === 'number') snap.sizeBytes = persistedSizes[id]; return snap },
         }
       }
       return undefined
@@ -274,6 +278,7 @@ export function createMockCtx(opts) {
     actor: sid,
     setRoots: function (list) { rootsList = list || [] }, // 清空/改写活跃 root 集（模拟休眠/重建窗口）
     persistedHeaders: persistedHeaders, // 持久会话表（sid → { id, parentSession }）；写 parentSession 模拟子会话
+    persistedSizes: persistedSizes, // 快照体积表（sid → sizeBytes 数字）；cleanup 体积主源断言用
 
     // 以真 RPC 语义调用捕获的 webServer 路由（POST /dsh-agent-board → readBody → handlers[method]）
     rpc: async function (method, args) {