dsh-agent-board 1.8.1 → 1.8.2

package/README.md

@@ -113,11 +113,11 @@ dsh plugin --profile web remove dsh-agent-board
 
 ## 功能总览
 
-**核心能力一页速览**（`★` 为 v1.7.5–1.8.1 新栈）：
+**核心能力一页速览**（`★` 为 v1.7.5–1.8.2 新栈）：
 
 - **看板**：六列状态流、拖拽 / 多选批量 / 文本·优先级·标签筛选、归档留档、会话隔离
 - **派发**：一次性 Worker / 独立 Verifier、依赖调度（DFS 环检测）、touches 文件级排他、可续跑 Worker、Team 托管、**spawn 落闸锁内重验**（spawnGateOk：claim 占位与落闸决策读同一把锁的同一份快照，terminate/dependsOn 后补 落在 spawn 在途窗口即弃权——竞态与后补依赖双双根治）、**高优干预分态**（intervene 无活跃 run 时区分「续跑窗口，干预随续跑注入」与「真无 run」，返回体带 state 字段）、**建卡派发预警**（将自动派发时 lintWarnings 瞬态提示「约 1s 内被领取，想占位请 draft:true」）
-- **验收治理** `★`：硬性验收脚本独立复跑、驳回全量带回重派、Verifier 自测指南（userTest）、风险队列「待你过目」、验收时序防护（Verifier 在场时主窗口抢批需显式 `force:true`；有活跃 run 的卡禁止归档；Verifier 迟到结论落 `lateVerdict` 留痕+迟到驳回直投告警，不再静默吞掉）
+- **验收治理** `★`：硬性验收脚本独立复跑、驳回全量带回重派、Verifier 自测指南（userTest）、风险队列「待你过目」、验收时序防护（Verifier 在场时主窗口抢批需显式 `force:true`；有活跃 run 的卡禁止归档；Verifier 迟到结论落 `lateVerdict` 留痕+直投告警）、**迟到 verdict 三保险**（①入参校验：`verdict` 非 approved/rejected 拒收并返回重调指引——漏带字段不再被当驳回落账；②通知分态：approved 迟到=「✅ 迟到复核·全过追认」notice 级，🚨「迟到驳回」只留给真 rejected；③指纹去重：同 taskId+by+verdict 只投一次，重复落账零重复通知）
 - **度量** `★`：Token 消耗（总量 / 有效 / 缓存读，按模型·按任务·按日）+ 记分卡（模型表现 / 质量趋势 / 驳回聚类）
 - **可运维性** `★`：运行时健康自检（派发冻结 / 结算停滞告警）、异常驱动审视（风险队列 / 质量异动告警 / 批次摘要）、起草 lint、数据安全（原子写盘 / 腐坏隔离 / 自动 salvage）、**僵尸 run 留档清扫**（host 重启后「落定卡上的 running 无 endedAt 留档」在派发周期自动关账 `stale-closed` + 清认领位，归档门禁不再被幻影 run 永久拦截）、**子会话生命周期收口**（一次性 run 落定/迟到 verdict 落账后主动 interrupt 子会话——「结算≠停止」空转根治；continuable 收紧为「续跑位真在本 child 手上」才豁免，残影 Worker 无处藏身）、**terminate 三保险**（no-rec 也按认领位盲杀补刀 + interrupt 失败 err 级可见化 + `hold:true` 原子「终止+转手动」）、**配置审计**（set-board-config 成功写入落板级 configLog {key,from,to,actor,at} 截尾 50 条；模型下拉两段式选中≠保存）
 - **学习反馈**：候选教训信号 → 主窗口沉淀（零耦合，不碰任何笔记 / 记忆工具 API）

package/index.mjs

@@ -71,6 +71,7 @@ export function apply(ctx) {
       withTimeout: session.withTimeout, runsFor: session.runsFor, feedbackOn: session.feedbackOn, epicSplitOn: session.epicSplitOn,
       pushSysNote: notify.pushSysNote, maybeNotify: notify.maybeNotify, notifyTaskDone: notify.notifyTaskDone,
       notifyDispatched: notify.notifyDispatched, notifyLateReject: notify.notifyLateReject,
+      notifyLateApprove: notify.notifyLateApprove, // 迟到复核分态通知（三连根修②，task-mvf7nve8）
     })
     storeDeps.poolCycle = dispatch.poolCycle // 晚绑定收口
     // 僵尸 epic 出清配套（反馈 n-mutma3mmwceq）：archive-task 门禁的活性判定。
@@ -82,6 +83,7 @@ export function apply(ctx) {
       rootForSession: session.rootForSession, deriveWorkMode: session.deriveWorkMode, runsFor: session.runsFor,
       rt: store.rt, mutateLocked: store.mutateLocked,
       maybeNotify: notify.maybeNotify, notifyTaskDone: notify.notifyTaskDone, notifyLateReject: notify.notifyLateReject,
+      notifyLateApprove: notify.notifyLateApprove, // 迟到复核分态通知（三连根修②，task-mvf7nve8）
       pushSysNote: notify.pushSysNote, sessionCwd: session.sessionCwd, // 调研门禁③：epic 发布预检汇总投递 + 预研路径相对解析根
       spawnOneShot: dispatch.spawnOneShot, accumulateRunUsage: dispatch.accumulateRunUsage, readContextPack: dispatch.readContextPack,
       closeRunHistory: dispatch.closeRunHistory, // 手动终止 run 关账（doTerminate 状态无关清理，task-mv1pqy27）

package/lib/core.mjs

@@ -602,6 +602,22 @@ export function pushRejection(t, summary, checks, at, by) {
   return true
 }
 
+// ===== verdict 入参校验（迟到 verdict 三连根修①，task-mvf7nve8）=====
+// 事故实证：Verifier 调 board_verdict 漏带 verdict 字段，undefined 直写 lateVerdict/verification，
+// 被 lateRejected=!approved 当驳回 → err 级「迟到驳回」误报 + 重复投递。board_verdict 工具通道与
+// late 落账双闸：缺失/非 'approved'|'rejected' 一律拒收（返回错误串），调用方不落账不通知——
+// 模型拿到错误会带正确字段重调。主窗口 task_verify/verify-task 人工通道不经此闸（schema 已枚举约束）。
+export function verdictErr(verdict) {
+  if (verdict === 'approved' || verdict === 'rejected') return null
+  return 'verdict 必须是 approved 或 rejected（收到：' + String(verdict) + '），请带正确字段重调'
+}
+// 迟到通知同指纹去重（三连根修③）：指纹 = taskId+by+verdict，rpc/dispatch 两调用点共用，
+// 存 poolHealth[sid].lastLateNotice（sticky 内存级，host 重启自然清）——同指纹二次落账零重复通知。
+export function lateNoticeFp(t) {
+  var lv = (t && t.lateVerdict) || {}
+  return String((t && t.id) || '') + '|' + String(lv.by || '') + '|' + String(lv.verdict || '')
+}
+
 // ===== 迟到 verdict 落账（验收时序三洞 ③，用户 n-mv0ebretgv1o）=====
 // 事故：主窗口在 Verifier 活跃期 task_verify 抢批（早 0.4s）+ 归档，Verifier 的独立结论与自测
 // 指南被静默吞掉、无回执。修法：verifier 结论（工具通道 board_verdict / 文本通道 settleVerifier）
@@ -612,6 +628,8 @@ export function pushRejection(t, summary, checks, at, by) {
 // 返回 { lateRejected, wasApproved }：调用方据此决定要不要发 err 级通知 + healthHint
 // （I/O 留在调用方，core 保持零依赖）。wasApproved 必须先算——下方可能覆写 t.verification。
 export function lateVerdictApply(t, verdict, summary, checks, userTest, at, by, verifyUserGuideOn) {
+  var vErr = verdictErr(verdict) // 三连根修①：非法 verdict 零落账（undefined 不再被当驳回）
+  if (vErr) return { ok: false, invalid: true, error: vErr, lateRejected: false, wasApproved: false }
   var approved = verdict === 'approved'
   var wasApproved = t.status === 'resolved' || (t.status === 'archived' && !!(t.verifiedAt || t.verifiedBy || (t.verification && t.verification.verdict === 'approved')))
   t.lateVerdict = { verdict: verdict, summary: summary || '', checks: checks || '', at: at || new Date().toISOString(), by: by || 'system', note: '迟到结论：卡在落定后收到' }

package/lib/dispatch.mjs

@@ -7,7 +7,7 @@ import { statSync } from 'node:fs'
 import * as core from './core.mjs'
 import { readRunUsage, findRunLog, readLogBytes, readLogFrames } from './usage.mjs'
 import { splitRuleOf, pushRejectLesson } from './policy.mjs'
-const { ah, cfg, claimApply, resolveApply, verifyApply, lateVerdictApply, parseSections, outputText, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseContextFileEntry, parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER } = core
+const { ah, cfg, claimApply, resolveApply, verifyApply, lateVerdictApply, lateNoticeFp, parseSections, outputText, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseContextFileEntry, parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER } = core
 
 export function createDispatch(ctx, state, deps) {
     // 宿主 fs 句柄与「会话工作区解析根」随预研注入瘦身退役（task-muvjs392）：派发侧不再读盘——
@@ -23,6 +23,7 @@ export function createDispatch(ctx, state, deps) {
     var epicSplitOn = deps.epicSplitOn
     var pushSysNote = deps.pushSysNote, maybeNotify = deps.maybeNotify, notifyTaskDone = deps.notifyTaskDone
     var notifyLateReject = (typeof deps.notifyLateReject === 'function') ? deps.notifyLateReject : null // 迟到驳回 err 级通知（未接线 → 静默跳过）
+    var notifyLateApprove = (typeof deps.notifyLateApprove === 'function') ? deps.notifyLateApprove : null // 迟到复核 notice 级通知（三连根修②，未接线 → 静默跳过）
     // 派发即回执：spawn 成功后入 45s 聚合队列的「🚀 已派发」区（老 host 未注入 → 静默跳过）
     var notifyDispatched = deps.notifyDispatched
     // 共享状态别名（本体由 index.mjs apply 统一构建并逐模块注入）
@@ -997,6 +998,7 @@ export function createDispatch(ctx, state, deps) {
             var lapproved = lvm[1].toUpperCase() === 'APPROVED'
             var lsecs = parseSections(ltrim)
             var lr = lateVerdictApply(t, lapproved ? 'approved' : 'rejected', lsecs.verifySummary || ltrim.slice(0, 600), lsecs.checks || '', lsecs.userTest, new Date().toISOString(), String(rec.id), cfg(d).verifyUserGuide)
+            if (lr && lr.invalid) return { task: t, already: true } // 三连根修①：非法 verdict 零落账（防御——本路径 verdict 恒来自正则解析）
             return { task: t, late: true, lateRejected: lr.lateRejected && lr.wasApproved }
           }
           return { task: t, already: true }
@@ -1044,11 +1046,19 @@ export function createDispatch(ctx, state, deps) {
       if (!result) return
       // already=true：工具通道（board_verdict）已推进状态并已发回执，settle 只负责 dispose，不再重复通知
       if (result.already) return
-      // 迟到驳回（验收时序三洞 ③）：verdict=rejected 且卡已 approved → err 级通知 + healthHint
+      // 迟到通知分态（三连根修②③，task-mvf7nve8）：rejected 且卡已 approved → err 级「🚨 迟到驳回」+
+      // healthHint（banner 只 rejected 亮）；approved → notice 级「✅ 迟到复核：维持原判」。
+      // 同指纹（taskId+by+verdict，poolHealth.lastLateNotice）已投过 → 跳过，零重复通知。
       if (result.late) {
+        var __phL = poolHealthFor(sid)
+        var __fpL = lateNoticeFp(result.task)
+        var __onceL = __phL.lastLateNotice !== __fpL
+        if (__onceL) __phL.lastLateNotice = __fpL
         if (result.lateRejected) {
-          if (notifyLateReject) notifyLateReject(sid, result.task)
-          poolHealthFor(sid).lateRejectNote = { taskId: result.task.id, at: Date.now() }
+          __phL.lateRejectNote = { taskId: result.task.id, at: Date.now() } // banner 幂等 sticky，不受去重闸影响
+          if (__onceL && notifyLateReject) notifyLateReject(sid, result.task)
+        } else if (__onceL && notifyLateApprove && result.task.lateVerdict && result.task.lateVerdict.verdict === 'approved') {
+          notifyLateApprove(sid, result.task)
         }
         return
       }

package/lib/health.mjs

@@ -211,6 +211,8 @@ export function computeRuntimeHealthHints(board, rt, opts) {
   // 主窗口 force 抢批后 Verifier 迟到驳回：err 级 hint（sticky 不 TTL——host 重启才清），
   // 与 corruptNote 同款「进行中的事故优先」语义。rt.lateRejectNote 由 board_verdict/settleVerifier
   // 迟到落账路径写入（dispatch.mjs poolHealthFor / rpc.mjs state.poolHealth）。
+  // 只 rejected 亮（三连根修②⑤，task-mvf7nve8）：approved 迟到结论走 notice 级「✅ 迟到复核」
+  // 直投，绝不写 lateRejectNote——err banner 不为「维持原判」误亮。
   var lr = rt.lateRejectNote
   if (lr && typeof lr === 'object' && lr.taskId) {
     out.hints.push({ level: 'err', text: '迟到驳回：' + String(lr.taskId) + ' 你批早了但 Verifier 验出红的' })

package/lib/notify.mjs

@@ -205,5 +205,17 @@ export function createNotify(ctx, state, deps) {
       } catch (e) { console.error('[task-board] late reject notify failed:', String(e)) }
     }
 
-    return { maybeNotify: maybeNotify, notifyTaskDone: notifyTaskDone, notifyDispatched: notifyDispatched, pushSysNote: pushSysNote, notifyBoardCorrupt: notifyBoardCorrupt, notifyLateReject: notifyLateReject }
+    // ===== 迟到复核通知（迟到 verdict 三连根修②，task-mvf7nve8）：approved 迟到结论 → notice 级直投同通道 =====
+    // 与 notifyLateReject 同纪律（直投 owner、不走开关/聚合），但标题正文如实——「维持原判（全过追认）」，
+    // 不亮 err 级「迟到驳回」（此前 undefined verdict 让全过卡被记驳回的事故形态就此绝迹）。
+    function notifyLateApprove(sid, t) {
+      var root = rootForSession(sid)
+      if (!root) return
+      var lv = (t && t.lateVerdict) || {}
+      try {
+        root.followup(makeMsg('✅ [任务看板] 迟到复核：' + (t.id || '') + ' 维持原判（全过追认）\n\n任务: ' + String(t.title || '') + ' (' + (t.id || '') + ')\n\nVerifier 结论（迟到）: ' + String(lv.summary || '(无)') + '\n核对项: ' + String(lv.checks || '(无)') + '\n\n卡已落定，本次迟到结论与之一致，仅留痕详情页「迟到 Verifier 结论」块。', 'notice', '迟到复核: ' + (t.id || '')))
+      } catch (e) { console.error('[task-board] late approve notify failed:', String(e)) }
+    }
+
+    return { maybeNotify: maybeNotify, notifyTaskDone: notifyTaskDone, notifyDispatched: notifyDispatched, pushSysNote: pushSysNote, notifyBoardCorrupt: notifyBoardCorrupt, notifyLateReject: notifyLateReject, notifyLateApprove: notifyLateApprove }
 }

package/lib/rpc.mjs

@@ -14,7 +14,7 @@ import { makeMsg } from './notify.mjs'
 import { computeHealthHints, computeRuntimeHealthHints } from './health.mjs'
 import { isFullSessionId } from './session.mjs' // 幻影板防线口径（纯函数，与 policy.mjs 直引同例）
 import { previewCleanup, runCleanup, SKIP_REASON_TEXT } from './cleanup.mjs' // 已结算会话清理（预览+执行）
-const { ah, isb, gsb, gpt, vt, validateDeps, classifyPipeline, cfg, claimCheck, claimApply, resolveApply, verifyApply, lateVerdictApply, archiveApply, cancelApply, maybeAutoCloseParent, PRIO_RANK, touchesConflict, holdsFiles, boardHome, aggregateChildStats, createTaskWarnings, epicPrecheck, epicPrecheckNote, attachContextSuggestions, REJECT_REDISPATCH_HINT, tasksHash, normalizeHooks, mergeHooks, pushRejection, normalizeUserTest, draftLint, appendDispatchWarning } = core
+const { ah, isb, gsb, gpt, vt, validateDeps, classifyPipeline, cfg, claimCheck, claimApply, resolveApply, verifyApply, lateVerdictApply, verdictErr, lateNoticeFp, archiveApply, cancelApply, maybeAutoCloseParent, PRIO_RANK, touchesConflict, holdsFiles, boardHome, aggregateChildStats, createTaskWarnings, epicPrecheck, epicPrecheckNote, attachContextSuggestions, REJECT_REDISPATCH_HINT, tasksHash, normalizeHooks, mergeHooks, pushRejection, normalizeUserTest, draftLint, appendDispatchWarning } = core
 
 function defineTool(options) {
   var userExecute = options.execute
@@ -84,6 +84,7 @@ export function createRpc(ctx, state, deps) {
     }
     var maybeNotify = deps.maybeNotify, notifyTaskDone = deps.notifyTaskDone
     var notifyLateReject = (typeof deps.notifyLateReject === 'function') ? deps.notifyLateReject : null // 迟到驳回 err 级通知（未接线 → 静默跳过）
+    var notifyLateApprove = (typeof deps.notifyLateApprove === 'function') ? deps.notifyLateApprove : null // 迟到复核 notice 级通知（三连根修②，未接线 → 静默跳过）
     var spawnOneShot = deps.spawnOneShot, accumulateRunUsage = deps.accumulateRunUsage, readContextPack = deps.readContextPack
     // 手动终止的 run 关账（outcome:'terminated'，task-mv1pqy27 死结窗口根修）：与状态无关，
     // 凡 terminate 命中该卡的 run 就关。未注入（老宿主/测试桩）→ 静默跳过，行为与改造前逐字一致。
@@ -131,6 +132,17 @@ export function createRpc(ctx, state, deps) {
       var ph = state.poolHealth[sid] || (state.poolHealth[sid] = { bornAt: Date.now() })
       ph.lateRejectNote = { taskId: taskId, at: Date.now() }
     }
+    // 迟到通知同指纹去重（三连根修③，task-mvf7nve8）：指纹（taskId+by+verdict）记入
+    // poolHealth[sid].lastLateNotice（sticky 内存级），已投过返回 false——同一结论经 RPC+
+    // settle 兜底+模型重调多次落账时零重复通知。
+    function lateNoticeOnce(sid, t) {
+      if (!state.poolHealth) state.poolHealth = {}
+      var ph = state.poolHealth[sid] || (state.poolHealth[sid] = { bornAt: Date.now() })
+      var fp = lateNoticeFp(t)
+      if (ph.lastLateNotice === fp) return false
+      ph.lastLateNotice = fp
+      return true
+    }
     // 终止未生效 healthHint 落点（terminate 假杀根修②，task-mv8jfu1v，事故实证 n-mv8cfndmvfcv）：
     // doTerminate 的 interrupt 抛错/无中断能力/补杀核验未过时写。与 lateRejectNote 同款 sticky——
     // 僵尸 Worker 继续写盘是进行中的数据安全事故，亮到人来处理（host 重启才清）。
@@ -911,6 +923,11 @@ export function createRpc(ctx, state, deps) {
     } }))
     ctx.tools.register(defineTool({ name: 'board_verdict', description: '[任务看板 Verifier 专用] 提交验收结论。verdict=approved/rejected；summary=测试概要；checks=逐条核对证据。userTest 可选：自测指南四字段 {gist=一句人话, steps=[用户操作步骤], expect=预期看到什么, tier=ui|metric|internal}（板级开关 verifyUserGuide 开启时随结论一并提交；tier=internal 时 steps 可空、expect 写「验证靠测试套件」）。', parameters: { type: 'object', properties: { taskId: { type: 'string' }, verdict: { type: 'string', enum: ['approved', 'rejected'] }, summary: { type: 'string' }, checks: { type: 'string' }, userTest: { type: 'object', properties: { gist: { type: 'string' }, steps: { type: 'array', items: { type: 'string' } }, expect: { type: 'string' }, tier: { type: 'string', enum: ['ui', 'metric', 'internal'] } } } }, required: ['taskId', 'verdict'] }, output: jo(), execute: async function (args) {
       var sid = toolSessionId(); var actor = getActorId()
+      // 入参校验（三连根修①，task-mvf7nve8）：verdict 缺失/非法 → 拒收带指引，不落账不通知
+      // （实证：Verifier 漏带 verdict，undefined 落账被 lateRejected 当驳回 → err 误报+重复投递）。
+      // 只闸本工具的 verifier 通道与 late 分支；主窗口 task_verify/verify-task 人工通道不受此限。
+      var __vErr = verdictErr(args.verdict)
+      if (__vErr) return { ok: false, error: __vErr }
       var approved = args.verdict === 'approved'
       var result = await mutateLocked(sid, function (d) {
         var t = d.tasks.find(function (x) { return x.id === args.taskId })
@@ -948,10 +965,17 @@ export function createRpc(ctx, state, deps) {
         var bt = result.task
         if ((bt.rejectCount || 0) < 3) { await mutateLocked(sid, function (d) { var t2 = d.tasks.find(function (x) { return x.id === bt.id }); if (t2 && t2.status === 'in-progress') { t2.status = 'pending'; t2.claimedBy = null; t2.claimedAt = null }; return t2 }, true) }
       }
-      // 迟到驳回（验收时序三洞 ③）：verdict=rejected 且卡已 approved → err 级通知（回执直投 owner，不走开关）+ healthHint
-      if (result && result.ok && result.late && result.lateRejected) {
-        if (notifyLateReject) notifyLateReject(sid, result.task)
-        markLateRejectHealth(sid, result.task.id)
+      // 迟到通知分态（三连根修②③，task-mvf7nve8）：verdict=rejected 且卡已 approved → err 级
+      // 「🚨 迟到驳回」直投 + healthHint（banner 只 rejected 亮）；verdict=approved → notice 级
+      // 「✅ 迟到复核：维持原判（全过追认）」直投同通道。同指纹（taskId+by+verdict）已投过 → 跳过。
+      if (result && result.ok && result.late) {
+        var __once = lateNoticeOnce(sid, result.task)
+        if (result.lateRejected) {
+          markLateRejectHealth(sid, result.task.id) // banner 幂等 sticky，不受去重闸影响
+          if (__once && notifyLateReject) notifyLateReject(sid, result.task)
+        } else if (__once && notifyLateApprove && result.task.lateVerdict && result.task.lateVerdict.verdict === 'approved') {
+          notifyLateApprove(sid, result.task)
+        }
       }
       // ===== 结算≠停止根修③（task-mv8wuznb，实证：verifier 迟到交付 verdict 落账后又空转 8h）=====
       // 迟到落账时该 verifier 的活跃 rec 通常早已被幽灵回收（卡落定即失活），settleRunRecord 的补停

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agent-board",
   "description": "DeepSeek Harness 智能看板：任务卡片 + 一次性 Worker/Verifier 派发 + 依赖调度 + 管线分档 + Team 模式（歧义上报主窗口裁决）",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "type": "module",
   "main": "./index.mjs",
   "scripts": {
@@ -63,7 +63,7 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@deepseek-ai/dsh": "^0.1.7 || 0.2.0-rc.2 || ^0.2.0"
+    "@deepseek-ai/dsh": "^0.1.7 || 0.2.0-rc.2 || 0.2.1-rc.2 || ^0.2.0"
   },
   "license": "MIT"
 }

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 验出红的/)
+})