dsh-agent-board 1.7.6 → 1.7.8

package/test/scoreboard-trends-client.test.mjs

@@ -8,6 +8,7 @@
 //   ③ 空态——整区空态灰字（锚 id 照挂）+ 单块空态灰字；无样本日画灰基线不假装 0%
 //   ④ caption 口径一句——看板派发 run 本体 + 驳回定义（验收 verdict rejected）
 //   ⑤ 接线与产物——Dashboard 在 ModelPerf 正下方挂载 QualityTrends；client.js 已重组装；README 双份同步
+//   ⑥ 重叠回归锁（task-mv11xd0o）——柱图容器 minWidth/overflow 三件套 + 柱高 clamp 22px（防单日 100% 柱越界盖右列）
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
@@ -102,3 +103,23 @@ test('卡4⑤：接线——Dashboard 挂载在 ModelPerf 正下方；产物已
   assert.equal(r1, r2, 'README 双份必须逐字一致（npm run sync-readme）')
   assert.ok(r1.indexOf('质量趋势') >= 0, 'README 仪表盘段缺「质量趋势」区说明')
 })
+
+// ===== ⑥ 重叠回归锁（task-mv11xd0o）：柱图容器 minWidth/overflow + 柱高 clamp =====
+// 缺陷复盘：范围收窄到单日 + 当日 100% 时，一次通过率黑柱向上越界盖住右侧「卡时长分布」面板标题/条形。
+// 锁法（源码级硬断言，防回归重跑）：① 柱图容器 minWidth:0 + overflow:hidden（flex 项不越界三件套）
+//   ② 柱高 clamp 到 22px（46px 绘图容器扣上下率值/日期标签与 gap/描边后不越出）
+test('卡4⑥：重叠回归锁——柱图容器 minWidth/overflow 三件套 + 柱高 clamp 22px', () => {
+  // ① 柱图容器锁：qtDayBars 容器带 minWidth:0 + overflow:hidden（flex 项不越界三件套）
+  const bars = sliceFn(src, 'qtDayBars')
+  assert.ok(bars.indexOf('height: 46, minWidth: 0, overflow: \'hidden\'') >= 0, 'qtDayBars 容器须带 minWidth:0 + overflow:hidden（flex 不越界三件套）')
+  // ① 柱体 cell 锁：flex:1 项必须 minWidth:0 才能收缩到容器内（否则 min-content 撑破容器越界）
+  assert.ok(bars.indexOf('flex: 1, minWidth: 0') >= 0, '柱体 cell 须带 minWidth:0（flex:1 项可收缩）')
+  // ① 左右分栏锁：block1（一次通过率）/ block3（超时率）左列容器 overflow:hidden 防越界盖右列
+  const blockLocks = src.split('flex: \'1 1 260px\', minWidth: 230, overflow: \'hidden\'').length - 1
+  assert.ok(blockLocks >= 2, 'block1/block3 左列容器须均带 overflow:hidden（命中 ' + blockLocks + ' 处，应 ≥2）')
+  // ② 柱高 clamp：100% 柱封顶 22px（防单日 100% 黑柱越出绘图容器）
+  assert.ok(src.indexOf('h = Math.min(22, h)') >= 0, '柱高须 clamp 到 22px（防单日 100% 黑柱越界）')
+  // 产物重组装：client.js 同源标记须存在（npm run build-client 已重组装）
+  assert.ok(built.indexOf('height: 46, minWidth: 0, overflow: \'hidden\'') >= 0, 'client.js 缺容器锁标记（需 npm run build-client 重组装）')
+  assert.ok(built.indexOf('h = Math.min(22, h)') >= 0, 'client.js 缺柱高 clamp 标记（需 npm run build-client 重组装）')
+})

package/test/store-data-safety.test.mjs

@@ -0,0 +1,217 @@
+// dsh-agent-board — 看板数据安全 P0 根修测试（task-mv0bl9vg）
+// 三件套：① 原子写盘（tmp+fsync+rename+unlink 兜底）② 腐坏隔离可见化（err hint + notify）
+//         ③ 自动 salvage 截断抢救（JSON.parse 报错 position 截断法）。
+// 全部跑在真实 index.mjs apply(mockCtx) 上；每个用例独立 mockCtx + 独立临时 HOME（HOME 是进程级，严禁并行）。
+// 建卡后不推进虚拟时钟 → 不触发派发，无 worker spawn 噪声。
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createMockCtx } from './helpers/mock-ctx.mjs'
+import * as plugin from '../index.mjs'
+import { createStore } from '../lib/store.mjs'
+
+function boardFile(env) { return path.join(env.home, '.dsh', 'tasks-' + env.sid + '.json') }
+
+// 建卡封装：显式 description 避开空描述软提示
+async function createTask(env, id, extra) {
+  var args = { sessionId: env.sid, id: id, title: '数据安全卡 ' + id, description: '看板数据安全根修测试' }
+  if (extra) { for (var k in extra) args[k] = extra[k] }
+  var r = await env.rpc('create-task', args)
+  assert.equal(r.ok, true, 'create-task 成功: ' + id)
+  return r.task
+}
+
+// ===== ① 原子写：源码断言 + 行为级（rename 瞬断后旧文件不被撕裂）=====
+test('① 原子写（源码级）：store.mjs 写盘含 tmp+fsync+rename+unlink 兜底', () => {
+  var sto = fs.readFileSync(new URL('../lib/store.mjs', import.meta.url), 'utf8')
+  assert.match(sto, /async function writeTmpFsync/)        // fsync 专用写 tmp helper
+  assert.match(sto, /fh\.sync\(\)/)                         // fsync 落盘（先于 rename）
+  assert.match(sto, /fsNode\.promises\.rename\(tmp, p\)/)   // tmp → rename 覆盖目标
+  assert.match(sto, /unlinkRetry\(p, 6\)/)                  // 直覆失败降级 unlink 兜底
+  assert.match(sto, /降级 unlink\+rename/)                  // 降级记录（不静默）
+})
+
+test('① 原子写（行为级）：rename 瞬断（EBUSY 一次）→ 旧文件全程完整，退避重试后写回', async () => {
+  var env = createMockCtx()
+  plugin.apply(env.ctx)
+  var origRename = fs.promises.rename
+  try {
+    await createTask(env, 'a1')
+    var p = boardFile(env)
+    assert.equal(JSON.parse(fs.readFileSync(p, 'utf8')).tasks.length, 1, '初始一张卡，文件是完整 JSON')
+    // 注入一次瞬断：首次 rename 到主板路径时同步读盘取证 → 抛 EBUSY；之后恢复原样
+    var injected = false
+    var duringRename = null
+    fs.promises.rename = async function (from, to) {
+      if (!injected && String(to) === p) {
+        injected = true
+        duringRename = fs.readFileSync(p, 'utf8')           // 瞬断时刻主板文件内容取证
+        var e = new Error('EBUSY injected'); e.code = 'EBUSY'; throw e
+      }
+      return origRename.call(fs.promises, from, to)
+    }
+    await createTask(env, 'a2')
+    var after = JSON.parse(fs.readFileSync(p, 'utf8'))
+    assert.equal(after.tasks.length, 2, '退避重试后写盘成功，最终内容完整（未撕裂）')
+    assert.ok(injected, '瞬断确实被注入')
+    assert.equal(JSON.parse(duringRename).tasks.length, 1, '瞬断时刻旧文件仍是完整旧 JSON（rename 原子，绝不半写）')
+  } finally {
+    fs.promises.rename = origRename
+    await env.cleanup()
+  }
+})
+
+// ===== ② 腐坏隔离：坏文件 → 隔离 .corrupt + err hint + notify（不再静默）=====
+test('② 腐坏隔离：无法抢救的坏文件 → 隔离留档 + err hint + notify owner', async () => {
+  var env = createMockCtx()
+  plugin.apply(env.ctx)
+  try {
+    await createTask(env, 'b1')
+    var p = boardFile(env)
+    // 构造「无法抢救」的坏文件：单对象中部截断（无 position 可截 → salvage 失败 → 隔离）
+    fs.writeFileSync(p, '{"ownerSession":"' + env.sid + '","tasks":[{"id":"x"}', 'utf8')
+    var d = await env.rpc('get-tasks', { sessionId: env.sid })
+    assert.ok(Array.isArray(d.tasks) && d.tasks.length === 0, '隔离后空板重启')
+    var errHint = (d.healthHints || []).find(function (h) { return h && h.level === 'err' })
+    assert.ok(errHint, '隔离产出 err 级 hint')
+    assert.match(errHint.text, /腐坏已隔离/)
+    assert.match(errHint.text, /\.corrupt-/)
+    var corrupts = fs.readdirSync(path.join(env.home, '.dsh')).filter(function (f) { return f.indexOf('.corrupt-') >= 0 })
+    assert.equal(corrupts.length, 1, '坏文件已改名 .corrupt-<ts> 留档')
+    var msg = env.sent.find(function (m) { return m && m.content && /腐坏已隔离/.test(m.content[0].text) })
+    assert.ok(msg, 'notify 通知 owner 会话（不再静默）')
+  } finally { await env.cleanup() }
+})
+
+// ===== ③ 自动 salvage：完整 JSON + 撕裂残片 → 截断抢救出第一段完整板 =====
+test('③ 自动 salvage：完整 JSON 尾部夹杂撕裂残片 → 截断抢救出第一段完整板并写回', async () => {
+  var env = createMockCtx()
+  plugin.apply(env.ctx)
+  try {
+    await createTask(env, 'c1')
+    await createTask(env, 'c2')
+    await createTask(env, 'c3')
+    var p = boardFile(env)
+    var good = fs.readFileSync(p, 'utf8')
+    assert.equal(JSON.parse(good).tasks.length, 3, '前置：三张卡落盘')
+    // 构造真实腐坏样本形态：完整 JSON 尾部夹杂「另一版本残片」（未闭合的第二个 JSON 值）
+    var torn = good + '{"ownerSession":"' + env.sid + '","tasks":[{"id":"c4","title":"撕裂残片","status":"pend'
+    fs.writeFileSync(p, torn, 'utf8')
+    var d = await env.rpc('get-tasks', { sessionId: env.sid })
+    assert.equal(d.tasks.length, 3, '抢救出完整第一段（3 张卡），丢弃撕裂残片')
+    var after = JSON.parse(fs.readFileSync(p, 'utf8'))
+    assert.equal(after.tasks.length, 3, '抢救结果已原子写回主板文件（不再反复 poison）')
+    var errHint = (d.healthHints || []).find(function (h) { return h && h.level === 'err' })
+    assert.ok(errHint, '抢救产出 err 级 hint')
+    assert.match(errHint.text, /抢救保留 3 张卡/)
+    var corrupts = fs.readdirSync(path.join(env.home, '.dsh')).filter(function (f) { return f.indexOf('.corrupt-') >= 0 })
+    assert.equal(corrupts.length, 1, '原始撕裂文件已留档 .corrupt-<ts>')
+    var msg = env.sent.find(function (m) { return m && m.content && /抢救/.test(m.content[0].text) })
+    assert.ok(msg, 'notify 通知 owner（抢救型）')
+  } finally { await env.cleanup() }
+})
+
+// ===== ④ P1 根修（task-mv1e17x9）：tmp 唯一名 + 四条锁外写路径归一（原子写时代撕裂根修）=====
+
+// 直连 store 层的最小环境：只测 wt() 原子写 / tmp 残件清理，不拉起整个插件。
+// 独立接管 process.env.HOME（与 createMockCtx 同款纪律：HOME 是进程级，用例串行 + finally 恢复）。
+function makeRawStore() {
+  var home = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-board-wt-'))
+  fs.mkdirSync(path.join(home, '.dsh'), { recursive: true })
+  var prevHome = process.env.HOME
+  var hadHome = Object.prototype.hasOwnProperty.call(process.env, 'HOME')
+  process.env.HOME = home
+  var state = { fileLocks: {}, cyclePending: {}, poolHealth: {}, teamModeCache: {}, feedbackCache: {}, epicSplitCache: {} }
+  var store = createStore({}, state, { sessionCwd: function () { return home } })
+  return {
+    store: store, home: home,
+    cleanup: function () {
+      if (hadHome) process.env.HOME = prevHome
+      else delete process.env.HOME
+      try { fs.rmSync(home, { recursive: true, force: true }) } catch (_) {}
+    },
+  }
+}
+
+test('④ tmp 唯一名（源码级）：wt() 的 tmp 名 = pid + 时间戳 + 进程内自增序号', () => {
+  var sto = fs.readFileSync(new URL('../lib/store.mjs', import.meta.url), 'utf8')
+  assert.match(sto, /process\.pid/)          // tmp 名含 pid（跨进程也唯一）
+  assert.match(sto, /Date\.now\(\)/)          // 含时间戳
+  assert.match(sto, /\+\+tmpSeq/)             // 含进程内自增序号（同 ms 并发也唯一）
+  assert.match(sto, /\+ '\.tmp'/)             // 仍是 .tmp 后缀
+  assert.match(sto, /var tmpSeq = 0/)         // 序号计数器声明（模块级，跨 store 实例共享）
+})
+
+test('④ tmp 唯一名（行为级）：两个并发 3MB 写后文件必是其中一份完整 JSON，且无 .tmp 残件', async () => {
+  var env = makeRawStore()
+  var sid = 'session-wt-' + Date.now().toString(36)
+  try {
+    var fillerA = 'A'.repeat(3 * 1024 * 1024)
+    var fillerB = 'B'.repeat(3 * 1024 * 1024)
+    var dA = { ownerSession: sid, tasks: [], marker: 'A', filler: fillerA }
+    var dB = { ownerSession: sid, tasks: [], marker: 'B', filler: fillerB }
+    var a = JSON.stringify(dA), b = JSON.stringify(dB)
+    await Promise.all([env.store.wt(sid, dA), env.store.wt(sid, dB)])
+    var p = path.join(env.home, '.dsh', 'tasks-' + sid + '.json')
+    var final = fs.readFileSync(p, 'utf8')
+    assert.ok(final === a || final === b, '最终文件必是其中一份完整 JSON（不是拼接怪）')
+    var leftovers = fs.readdirSync(path.join(env.home, '.dsh')).filter(function (f) { return /\.tmp$/.test(f) })
+    assert.equal(leftovers.length, 0, '成功写盘后无 .tmp 残件')
+  } finally { env.cleanup() }
+})
+
+test('④ 无 .tmp 残件（行为级）：rename 非瞬时失败后清理自己的 tmp', async () => {
+  var env = makeRawStore()
+  var sid = 'session-wt-fail-' + Date.now().toString(36)
+  var origRename = fs.promises.rename
+  try {
+    var p = path.join(env.home, '.dsh', 'tasks-' + sid + '.json')
+    await env.store.wt(sid, { ownerSession: sid, tasks: [] })           // 先正常写一次
+    assert.ok(fs.existsSync(p), '前置：主板已落盘')
+    fs.promises.rename = async function () { var e = new Error('EIO injected'); e.code = 'EIO'; throw e }
+    try { await env.store.wt(sid, { ownerSession: sid, tasks: [] }) } catch (_) {}
+    var leftovers = fs.readdirSync(path.join(env.home, '.dsh')).filter(function (f) { return /\.tmp$/.test(f) })
+    assert.equal(leftovers.length, 0, 'rename 失败后无 .tmp 残件（残件已被清理）')
+  } finally {
+    fs.promises.rename = origRename
+    env.cleanup()
+  }
+})
+
+test('④ 锁归一（源码级）：四条锁外写路径全部归一进 withLock，dispatch 不再直写 wt', () => {
+  var sto = fs.readFileSync(new URL('../lib/store.mjs', import.meta.url), 'utf8')
+  var disp = fs.readFileSync(new URL('../lib/dispatch.mjs', import.meta.url), 'utf8')
+  // 锁感知写回 + 不可重入死锁说明必须显式存在
+  assert.match(sto, /function lockAware\(sid, locked, fn\)/)
+  assert.match(sto, /withLock 是简单 promise 链，不可重入/)
+  assert.match(sto, /async function adoptBoard\(sid, cand, cwd, locked\)/)
+  assert.match(sto, /async function recoverCorrupt\(sid, raw, locked\)/)
+  assert.match(sto, /return lockAware\(sid, locked, async function \(\)/)
+  assert.match(sto, /await rt\(sid, true\)/)                          // mutateLocked 锁内调用 rt 传 true
+  // poolCycle 空闲快进清理：不再直写 wt，改走 mutateLocked（锁内重读重判）
+  assert.doesNotMatch(disp, /await wt\(/)
+  assert.doesNotMatch(disp, /deps\.wt/)
+  assert.match(disp, /mutateLocked\(sid, function \(d\) \{/)
+})
+
+test('④ poolCycle 空闲清理（行为级）：残留忙碌 poolStatus 经锁被清空', async () => {
+  var env = createMockCtx()
+  plugin.apply(env.ctx)
+  try {
+    await createTask(env, 'idle1')                                      // 建卡 + touchSession 入 knownSessions
+    // 模拟 DSH 重启：内存 runs 已空、文件里残留重启前的忙碌快照 + 无活跃任务 → 走空闲快进清理
+    env.patchBoard(function (d) {
+      d.tasks = []
+      d.poolStatus = { workers: [{ id: 'ghost-w', taskId: 'x', role: 'worker' }], verifiers: [{ id: 'ghost-v', taskId: 'y', role: 'verifier' }] }
+    })
+    await env.clock.tick()                                              // 触发 15s 心跳 → poolCycle → 空闲清理
+    await env.waitFor(function () {
+      var b = env.board()
+      return b && b.poolStatus.workers.length === 0 && b.poolStatus.verifiers.length === 0
+    })
+    var b = env.board()
+    assert.equal(b.poolStatus.workers.length + b.poolStatus.verifiers.length, 0, '残留忙碌 poolStatus 已被清空')
+  } finally { await env.cleanup() }
+})

package/test/verify-timing.test.mjs

@@ -0,0 +1,292 @@
+// dsh-agent-board — 验收时序三洞根修（用户 n-mv0ebretgv1o）：task_verify 抢跑守卫 + 归档门禁查活跃 run + 迟到 verdict 落账
+// 事故：主窗口在 Verifier 活跃期 task_verify 抢批（早 0.4s）+ 归档，Verifier 的 verdict/自测指南被静默吞掉、无回执。
+// 三洞逐一锁：① 抢跑守卫（force 通道）② 归档门禁查活跃 run ③ 迟到 verdict 落 lateVerdict/回执/userTest 补挂。
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createRpc } from '../lib/rpc.mjs'
+import { createDispatch } from '../lib/dispatch.mjs'
+import * as core from '../lib/core.mjs'
+
+const FULL_SID = 'session-mock-timing-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 || [] } }
+
+function waitFor(fn, label, ms) {
+  var t0 = Date.now(); var cap = ms || 2000
+  var p = function () { return new Promise(function (r) { setTimeout(r, 5) }) }
+  return (async function () {
+    for (;;) {
+      var v; try { v = await fn() } catch (_) { v = null }
+      if (v) return v
+      if (Date.now() - t0 > cap) throw new Error('waitFor 超时（' + cap + 'ms）: ' + (label || '(未命名)'))
+      await p()
+    }
+  })()
+}
+
+// ===== RPC/工具直调 harness（board_verdict / task_verify / archive-task / batch-op 三洞行为）=====
+function mkRpcHarness(board, runsTable, extra) {
+  const state = { handlers: {}, teamModeCache: {}, feedbackCache: {}, epicSplitCache: {}, poolHealth: {} }
+  const tools = {}
+  const lateRejects = []
+  const ctx = { tools: { register(t) { tools[t.name] = t } }, effect() {}, webServer: { register() { return () => {} } } }
+  const deps = Object.assign({
+    getActorId: () => 'tester', resolveRoot: (x) => x,
+    toolSessionId: () => FULL_SID, rpcSessionId: () => FULL_SID,
+    rootForSession: () => null, deriveWorkMode: () => 'solo',
+    runsFor: (sid) => (runsTable[sid] || {}),
+    rt: async () => board, mutateLocked: (sid, fn) => fn(board),
+    maybeNotify: () => {}, notifyTaskDone: () => {},
+    spawnOneShot: () => {}, accumulateRunUsage: () => {}, readContextPack: async () => null,
+    pushSysNote: () => {}, sessionCwd: () => '',
+    hasActiveRun: () => false,
+    notifyLateReject: (sid, t) => { lateRejects.push({ sid: sid, id: t.id }) },
+  }, extra || {})
+  createRpc(ctx, state, deps)
+  state.handlers.__tools = tools
+  state.handlers.__lateRejects = lateRejects
+  state.handlers.__state = state
+  return state.handlers
+}
+
+// ===== dispatch harness（settleVerifier 文本通道迟到落账）=====
+function mkSettleHarness(board) {
+  var runs = {}
+  var resolveRun = null
+  var boardRef = { b: board }
+  var lateRejects = []
+  var state = { knownSessions: {}, dispatchedEver: {}, badModels: {}, teamModeCache: {}, activeRuns: {}, poolHealth: {} }
+  var ctx = {
+    fs: {}, effect: function () {}, get: function () { return null }, timer: null,
+    subagents: {
+      list: function () { return ['mock'] },
+      getProvider: function () { return { inheritsParentContext: false } },
+      start: async function () { return { id: 'run-v1', result: new Promise(function (res) { resolveRun = res }), dispose: async function () {} } },
+    },
+  }
+  var dispatch = createDispatch(ctx, state, {
+    rt: async function () { return boardRef.b }, wt: async function () {}, mutateLocked: async function (sid, fn) { return fn(boardRef.b) },
+    kickCycle: function () {}, rootForSession: function () { return { id: FULL_SID } }, sessionCwd: function () { return '' },
+    withTimeout: function (p) { return p }, runsFor: function () { return runs }, feedbackOn: function () { return true }, epicSplitOn: function () { return true },
+    pushSysNote: function () {}, maybeNotify: function () {}, notifyTaskDone: function () {},
+    notifyLateReject: function (sid, t) { lateRejects.push(t.id) },
+  })
+  return { dispatch: dispatch, state: state, lateRejects: lateRejects, settle: function (text) { resolveRun({ output: [{ type: 'text', text: text }], stopReason: 'completed' }) } }
+}
+
+// ===== ① task_verify / verify-task 抢跑守卫 =====
+test('① 抢跑守卫：verifier 活跃 → task_verify 工具 + verify-task RPC 拦截；force:true 放行；已 settled 不拦', async () => {
+  // RPC 通道：活跃 verifier rec → 拦截
+  const board = mkBoard([mkTask({ id: 'v1', status: 'verifying' })])
+  const runs = { [FULL_SID]: { 'v1': { id: 'run-v1', role: 'verifier', settled: false } } }
+  const h = mkRpcHarness(board, runs)
+  const r = await h['verify-task']({ taskId: 'v1', verdict: 'approved' })
+  assert.equal(r.ok, false)
+  assert.match(r.error, /Verifier 还在跑（run run-v1）/); assert.match(r.error, /force:true/)
+  assert.equal(board.tasks[0].status, 'verifying') // 未放行，状态不动
+  // RPC 通道：force:true → 放行
+  const r2 = await h['verify-task']({ taskId: 'v1', verdict: 'approved', force: true })
+  assert.equal(r2.ok, true); assert.equal(board.tasks[0].status, 'resolved')
+  // 工具通道同口径
+  const board2 = mkBoard([mkTask({ id: 'v2', status: 'verifying' })])
+  const runs2 = { [FULL_SID]: { 'v2': { id: 'run-v2', role: 'verifier', settled: false } } }
+  const h2 = mkRpcHarness(board2, runs2)
+  const r3 = await h2.__tools['task_verify'].execute({ taskId: 'v2', verdict: 'approved' }, {})
+  assert.equal(r3.ok, false); assert.match(r3.error, /Verifier 还在跑（run run-v2）/); assert.equal(r3.verifierActive, 'run-v2')
+  const r4 = await h2.__tools['task_verify'].execute({ taskId: 'v2', verdict: 'approved', force: true }, {})
+  assert.equal(r4.ok, true); assert.equal(board2.tasks[0].status, 'resolved')
+  // 已 settled 的 rec（Verifier 已结束）→ 不拦截
+  const board3 = mkBoard([mkTask({ id: 'v3', status: 'verifying' })])
+  const runs3 = { [FULL_SID]: { 'v3': { id: 'run-v3', role: 'verifier', settled: true } } }
+  const h3 = mkRpcHarness(board3, runs3)
+  const r5 = await h3['verify-task']({ taskId: 'v3', verdict: 'approved' })
+  assert.equal(r5.ok, true)
+})
+
+// ===== ② 归档门禁查活跃 run =====
+test('② 归档门禁：resolved 卡有活跃 verifier run（内存 rec / 卡面 running 留档）→ 拒绝；无活跃 run 放行', async () => {
+  // 内存活跃表（最实时）
+  const board = mkBoard([mkTask({ id: 'a1', status: 'resolved', verifiedAt: '2026-01-01T00:01:00Z', verifiedBy: 'tester', verifierRun: 'run-v' })])
+  const runs = { [FULL_SID]: { 'a1': { id: 'run-v', role: 'verifier', settled: false } } }
+  const h = mkRpcHarness(board, runs)
+  const r = await h['archive-task']({ taskId: 'a1' })
+  assert.equal(r.ok, false)
+  assert.match(r.error, /有活跃 run（verifier run-v 仍在跑）/); assert.match(r.error, /等它落定或先 terminate/)
+  assert.equal(board.tasks[0].status, 'resolved') // 未归档
+  // 卡面 runs 留档兜底（无内存 rec，但 outcome running 且无 endedAt 且 id 匹配 verifierRun）
+  const board2 = mkBoard([mkTask({ id: 'a2', status: 'resolved', verifiedAt: 'x', verifierRun: 'run-v2', runs: [{ role: 'verifier', id: 'run-v2', outcome: 'running' }] })])
+  const h2 = mkRpcHarness(board2, {})
+  const r2 = await h2['archive-task']({ taskId: 'a2' })
+  assert.equal(r2.ok, false); assert.match(r2.error, /有活跃 run（verifier run-v2 仍在跑）/)
+  // resolved 无活跃 run → 放行（既有行为不破）
+  const board3 = mkBoard([mkTask({ id: 'a3', status: 'resolved' })])
+  const h3 = mkRpcHarness(board3, {})
+  const r3 = await h3['archive-task']({ taskId: 'a3' })
+  assert.equal(r3.ok, true); assert.equal(board3.tasks[0].status, 'archived')
+  // batch-op archive 同门禁
+  const board4 = mkBoard([mkTask({ id: 'b1', status: 'resolved', verifierRun: 'run-b', runs: [{ role: 'verifier', id: 'run-b', outcome: 'running' }] }), mkTask({ id: 'b2', status: 'resolved' })])
+  const h4 = mkRpcHarness(board4, {})
+  const r4 = await h4['batch-op']({ op: 'archive', ids: ['b1', 'b2'] })
+  assert.equal(r4.ok, true); assert.equal(r4.done, 1)
+  assert.deepEqual(r4.skipped, ['b1']); assert.match(r4.reasons['b1'], /有活跃 run/)
+})
+
+// ===== ② 归档门禁 × terminate 语义死结回归（Verifier 驳回回归根修）=====
+test('② 回归：terminate verifier → verifierRun 认领位清空，归档不再误判活跃（此前永久无法归档死结）', async () => {
+  const board = mkBoard([mkTask({ id: 'a4', status: 'verifying', verifierRun: 'run-vX', runs: [{ role: 'verifier', id: 'run-vX', outcome: 'running' }] })])
+  const runs = { [FULL_SID]: { 'a4': { id: 'run-vX', role: 'verifier', settled: false } } }
+  const h = mkRpcHarness(board, runs)
+  // 终止：内存表摘除 + 认领位清空（与 in-progress 清 claimedBy 同口径）
+  const r = await h['terminate-agent']({ taskId: 'a4' })
+  assert.equal(r.ok, true); assert.equal(r.terminated, 'verifier:a4')
+  assert.equal(board.tasks[0].verifierRun, null)
+  assert.equal(board.tasks[0].verifierRunAt, undefined)
+  // 终止后主窗口补批（无需 force：已无活跃 verifier）→ resolved
+  const r2 = await h.__tools['task_verify'].execute({ taskId: 'a4', verdict: 'approved' }, {})
+  assert.equal(r2.ok, true); assert.equal(board.tasks[0].status, 'resolved')
+  // 归档：修复前这里会因卡面 run-vX 仍 running 而误报「有活跃 run」并永久拒绝
+  const r3 = await h['archive-task']({ taskId: 'a4' })
+  assert.equal(r3.ok, true); assert.equal(board.tasks[0].status, 'archived')
+})
+
+test('② 回归：无活跃 rec 的 stale verifying 卡（terminate 空转场景）→ terminate 仍清 verifierRun，解除死结', async () => {
+  const board = mkBoard([mkTask({ id: 'a5', status: 'verifying', verifierRun: 'run-vX', runs: [{ role: 'verifier', id: 'run-vX', outcome: 'running' }] })])
+  const h = mkRpcHarness(board, {}) // 内存表空：rec 已不在（重启/已摘），正是报错文案推荐「先 terminate」却空转的场景
+  const r = await h['terminate-agent']({ taskId: 'a5' })
+  assert.equal(r.ok, true); assert.equal(r.terminated, 'no-active-run')
+  assert.equal(board.tasks[0].verifierRun, null) // 认领位仍被清空 → 卡面兜底不再误判
+  const r2 = await h.__tools['task_verify'].execute({ taskId: 'a5', verdict: 'approved' }, {})
+  assert.equal(r2.ok, true); assert.equal(board.tasks[0].status, 'resolved')
+  const r3 = await h['archive-task']({ taskId: 'a5' })
+  assert.equal(r3.ok, true); assert.equal(board.tasks[0].status, 'archived')
+})
+
+// ===== ② 死结窗口根修（task-mv1pqy27）：terminate 认领位清理与状态无关 + 关 run 结局 terminated =====
+test('② 死结窗口：resolved/cancelled 态 terminate（rec 仍在内存表）→ 认领位清 + run 关账，立即 archive 放行', async () => {
+  // resolved 态窗口：卡已 resolved，但 verifier run 的 rec 还挂在内存表（~50ms 结算窗口）
+  const board = mkBoard([mkTask({ id: 'a6', status: 'resolved', verifierRun: 'run-vX', runs: [{ role: 'verifier', id: 'run-vX', outcome: 'running' }] })])
+  const runs = { [FULL_SID]: { 'a6': { id: 'run-vX', role: 'verifier', settled: false } } }
+  const closed = []
+  const h = mkRpcHarness(board, runs, { closeRunHistory: async (sid, taskId, runId, outcome) => { closed.push({ taskId: taskId, runId: runId, outcome: outcome }); var tt = board.tasks.find(function (x) { return x.id === taskId }); if (tt && Array.isArray(tt.runs)) { var rr = tt.runs[tt.runs.length - 1]; if (rr && rr.id === runId && rr.outcome === 'running') { rr.outcome = outcome; rr.endedAt = '2026-01-01T00:00:01Z' } } } })
+  const r = await h['terminate-agent']({ taskId: 'a6' })
+  assert.equal(r.ok, true); assert.equal(r.terminated, 'verifier:a6')
+  assert.equal(board.tasks[0].verifierRun, null) // 状态无关：resolved 态也清 verifierRun（旧代码只在 verifying 清 → 死结）
+  assert.deepEqual(closed, [{ taskId: 'a6', runId: 'run-vX', outcome: 'terminated' }]) // 关 run 结局 terminated
+  assert.equal(board.tasks[0].runs[0].outcome, 'terminated')
+  const r3 = await h['archive-task']({ taskId: 'a6' })
+  assert.equal(r3.ok, true); assert.equal(board.tasks[0].status, 'archived') // 立即 archive 放行（修复前永久拒）
+
+  // cancelled 态窗口：worker run 的 rec 仍在内存表，claimedBy 仍指已终止 run（closeRunHistory 未注入 = no-op 兜底，只靠认领位清）
+  const board2 = mkBoard([mkTask({ id: 'a7', status: 'cancelled', claimedBy: 'run-wX', claimedAt: '2026-01-01T00:00:00Z', runs: [{ role: 'worker', id: 'run-wX', outcome: 'running' }] })])
+  const runs2 = { [FULL_SID]: { 'a7': { id: 'run-wX', role: 'worker', settled: false } } }
+  const h2 = mkRpcHarness(board2, runs2)
+  const rw = await h2['terminate-agent']({ taskId: 'a7' })
+  assert.equal(rw.ok, true); assert.equal(rw.terminated, 'worker:a7')
+  assert.equal(board2.tasks[0].claimedBy, null); assert.equal(board2.tasks[0].claimedAt, null) // 状态无关：cancelled 态也清 claimedBy
+  const rw3 = await h2['archive-task']({ taskId: 'a7' })
+  assert.equal(rw3.ok, true); assert.equal(board2.tasks[0].status, 'archived') // 取消卡立即 archive 放行
+})
+
+// ===== ③④⑤ 迟到 verdict 落账（工具通道 board_verdict）=====
+test('③ 迟到 approved：board_verdict 落到已 resolved 卡 → 落 lateVerdict，不炸、状态不动', async () => {
+  const board = mkBoard([mkTask({ id: 'l1', status: 'resolved', verifiedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkRpcHarness(board, {})
+  const r = await h.__tools['board_verdict'].execute({ taskId: 'l1', verdict: 'approved', summary: '复跑通过', checks: '## 核对项\n- ok' }, {})
+  assert.equal(r.ok, true); assert.equal(r.late, true); assert.equal(r.lateRejected, false)
+  const t = board.tasks[0]
+  assert.equal(t.status, 'resolved') // 状态不动
+  assert.equal(t.lateVerdict.verdict, 'approved')
+  assert.equal(t.lateVerdict.summary, '复跑通过')
+  assert.match(t.lateVerdict.note, /迟到结论：卡在落定后收到/)
+  // 已落定卡上的 board_verdict 不触发正常回执/重派（返回体带 late 旗即可，无报错）
+})
+
+test('④ 迟到 rejected + 卡已 approved：board_verdict → err 通知 + healthHint（lateRejectNote）', async () => {
+  const board = mkBoard([mkTask({ id: 'l2', status: 'resolved', verifiedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkRpcHarness(board, {})
+  const r = await h.__tools['board_verdict'].execute({ taskId: 'l2', verdict: 'rejected', summary: '单测没过', checks: '## 核对项\n- 红' }, {})
+  assert.equal(r.ok, true); assert.equal(r.late, true); assert.equal(r.lateRejected, true)
+  const t = board.tasks[0]
+  assert.equal(t.lateVerdict.verdict, 'rejected')
+  // err 通知已投（notifyLateReject 捕获，直投 owner 不走回执聚合）
+  assert.equal(h.__lateRejects.length, 1); assert.equal(h.__lateRejects[0].id, 'l2')
+  // healthHint 落点（poolHealth.lateRejectNote，health.mjs computeRuntimeHealthHints 现算透出）
+  assert.equal(h.__state.poolHealth[FULL_SID].lateRejectNote.taskId, 'l2')
+})
+
+test('⑤ userTest 补挂：迟到结论带 userTest → 补挂 t.verification.userTest；开关关则不挂', async () => {
+  const ut = { gist: '改了验收时序', steps: ['打开看板'], expect: '看到提示', tier: 'ui' }
+  const board = mkBoard([mkTask({ id: 'l3', status: 'resolved', verifiedAt: '2026-01-01T00:01:00Z' })])
+  const h = mkRpcHarness(board, {})
+  await h.__tools['board_verdict'].execute({ taskId: 'l3', verdict: 'rejected', summary: 'x', userTest: ut }, {})
+  const t = board.tasks[0]
+  assert.ok(t.lateVerdict.userTest, 'lateVerdict 挂 userTest')
+  assert.ok(t.verification, '原 verification 缺 → 补建')
+  assert.equal(t.verification.userTest.gist, '改了验收时序')
+  assert.equal(t.verification.verdict, 'rejected') // 补建的 verification 用迟到结论的 verdict 兜底，非空
+  // 开关关 → 不挂 userTest、不补建 verification
+  const board2 = mkBoard([mkTask({ id: 'l4', status: 'resolved', verifiedAt: 'x' })]); board2.verifyUserGuide = false
+  const h2 = mkRpcHarness(board2, {})
+  await h2.__tools['board_verdict'].execute({ taskId: 'l4', verdict: 'rejected', summary: 'x', userTest: ut }, {})
+  const t2 = board2.tasks[0]
+  assert.equal(t2.lateVerdict.userTest, undefined)
+  assert.equal(t2.verification, undefined)
+})
+
+// ===== ③④ 迟到 verdict 落账（文本通道 settleVerifier）=====
+test('③④ settleVerifier 迟到：主窗口抢批 resolved 后 Verifier 迟到 REJECTED → 落 lateVerdict + 通知 + healthHint', async () => {
+  const t = mkTask({ id: 's1', status: 'verifying' })
+  const board = mkBoard([t])
+  const h = mkSettleHarness(board)
+  await h.dispatch.poolCycle(FULL_SID)
+  assert.equal(t.verifierRun, 'run-v1') // 已派 Verifier
+  // 主窗口抢批（早于 verifier 结算）：直接把卡置 resolved（等价 task_verify force approved，不写 t.verification）
+  t.status = 'resolved'; t.verifiedAt = '2026-01-01T00:01:00Z'; t.verifiedBy = 'tester'
+  h.settle('REJECTED: 交付物与验收脚本不符\n\n## 测试概要\nnpm test 未跑通\n\n## 核对项\n- 断言①红')
+  await waitFor(function () { return t.lateVerdict }, 'settleVerifier 迟到落 lateVerdict')
+  assert.equal(t.lateVerdict.verdict, 'rejected')
+  assert.match(t.lateVerdict.summary, /npm test 未跑通/)
+  assert.match(t.lateVerdict.checks, /断言①红/)
+  assert.match(t.lateVerdict.note, /迟到结论/)
+  // err 通知 + healthHint
+  assert.equal(h.lateRejects.length, 1); assert.equal(h.lateRejects[0], 's1')
+  assert.equal(h.state.poolHealth[FULL_SID].lateRejectNote.taskId, 's1')
+  // 状态不被迟到的驳回改写（仍 resolved，不再回 pending 重派）
+  assert.equal(t.status, 'resolved')
+})
+
+test('settleVerifier 迟到落账：工具通道已落账（verification.by === rec.id）→ 不重复落 lateVerdict', async () => {
+  const t = mkTask({ id: 's2', status: 'verifying' })
+  const board = mkBoard([t])
+  const h = mkSettleHarness(board)
+  await h.dispatch.poolCycle(FULL_SID)
+  assert.equal(t.verifierRun, 'run-v1')
+  // 模拟 board_verdict 工具通道已落账（by = 本 run 的 rec.id）并推进到 resolved
+  t.verification = { verdict: 'approved', summary: 'OK', checks: '', at: '2026-01-01T00:01:00Z', by: 'run-v1' }
+  t.status = 'resolved'; t.verifiedAt = '2026-01-01T00:01:00Z'
+  h.settle('APPROVED: ok')
+  await new Promise(function (r) { setTimeout(r, 50) }) // 给结算链一点时间跑完，确认不落 lateVerdict
+  assert.equal(t.lateVerdict, undefined)
+  assert.equal(t.verification.verdict, 'approved') // 原结论不被覆盖
+})
+
+// ===== 纯函数口径：lateVerdictApply wasApproved 判定 =====
+test('lateVerdictApply：wasApproved 口径（resolved / archived-from-resolved / archived-from-cancelled）', () => {
+  // resolved → approved
+  const t1 = mkTask({ id: 'p1', status: 'resolved', verifiedAt: 'x' })
+  assert.equal(core.lateVerdictApply(t1, 'rejected', 's', 'c', null, 'at', 'by', true).wasApproved, true)
+  // archived 且带 verifiedAt → approved
+  const t2 = mkTask({ id: 'p2', status: 'archived', verifiedAt: 'x' })
+  assert.equal(core.lateVerdictApply(t2, 'rejected', 's', 'c', null, 'at', 'by', true).wasApproved, true)
+  // archived 无 approved 痕迹（从 cancelled 归档）→ 非 approved
+  const t3 = mkTask({ id: 'p3', status: 'archived' })
+  assert.equal(core.lateVerdictApply(t3, 'rejected', 's', 'c', null, 'at', 'by', true).wasApproved, false)
+  // cancelled → 非 approved
+  const t4 = mkTask({ id: 'p4', status: 'cancelled' })
+  assert.equal(core.lateVerdictApply(t4, 'rejected', 's', 'c', null, 'at', 'by', true).wasApproved, false)
+  // approved verdict → lateRejected false
+  const t5 = mkTask({ id: 'p5', status: 'resolved', verifiedAt: 'x' })
+  const r5 = core.lateVerdictApply(t5, 'approved', 's', 'c', null, 'at', 'by', true)
+  assert.equal(r5.lateRejected, false); assert.equal(r5.wasApproved, true)
+})