dsh-agent-board 1.7.5 → 1.7.7

package/test/helpers/mock-ctx.mjs

@@ -9,7 +9,8 @@
 //   · subagents.start(provider, req)            → 一次性 run（result promise 由测试驱动落定/拒绝）
 //   · subagents.startContinuable({...})         → { childId, messageId }（持久子会话，turn 结算走 emitStatus）
 //   · subagents.sendMessage / interrupt / listChildren → 记录器 + 可剧本化
-//   · agents.currentInitiator()/roots()/list()/isOwnedBy() → 按测试剧本返回（缺省单 root，actor=root）
+//   · agents.currentInitiator()/roots()/list()/get()/isOwnedBy() → 按测试剧本返回（缺省单 root，actor=root；env.setRoots 可清空模拟休眠）
+//   · ctx.get('sessionPersistence')             → 持久会话表 stat(id)（env.persistedHeaders 可写 parentSession 模拟子会话/根会话）
 //   · tools.register / webServer.register       → 捕获工具表与 RPC 路由（env.rpc 走真 readBody/handler 路径）
 //   · ctx.get('systemPrompt'|'llm')             → 记录器（注册了什么段/查了什么模型都留痕）
 //   · ctx.effect / ctx.on('agent/status')       → 真实执行 + disposer 收口 / 事件捕获与重放
@@ -48,6 +49,8 @@ import { Readable } from 'node:stream'
  * @property {Object} spSections     systemPrompt 注册段记录器
  * @property {Object} llm            llm 记录器（listProviders/listModels 调用留痕）
  * @property {string} actor          currentInitiator 返回值（缺省=root sid；测试可改写模拟子代理身份）
+ * @property {(list:Object[])=>void} setRoots  改写活跃 root 集（传 [] 模拟休眠根会话/重建窗口）
+ * @property {Object} persistedHeaders  持久会话表 sid → { id, parentSession }（写 parentSession 模拟子会话；缺省根会话 parentSession=undefined）
  * @property {()=>Object} board      读当前看板文件 JSON（不存在返回 null）
  * @property {(id:string)=>Object|undefined} task  看板里按 id 取任务
  * @property {(fn:Function, label?:string, timeoutMs?:number)=>Promise<any>} waitFor  真实时间轮询直到条件为真（默认 5s 上限）
@@ -188,10 +191,14 @@ export function createMockCtx(opts) {
     // whenIdle 刻意不实现：flushReceipts 走「无空闲门控 → 立即投递」分支（45s 窗口到点即投，可断言）
   }
   var env // 前向引用（currentInitiator 读 env.actor）
+  var rootsList = [root] // 活跃 root 集（测试可 env.setRoots([]) 清空模拟「休眠根会话」）
+  var persistedHeaders = {} // 持久会话表 sid → SessionHeader（测试可写 parentSession 模拟子会话/根会话）
+  persistedHeaders[sid] = { id: sid, parentSession: undefined }
   var agents = {
     currentInitiator: function () { return { id: env.actor } },
-    roots: function () { return [root] },
-    list: function () { return [root] },
+    roots: function () { return rootsList },
+    list: function () { return rootsList.slice() },
+    get: function (id) { for (var i = 0; i < rootsList.length; i++) { if (String(rootsList[i].id) === String(id)) return rootsList[i] } return undefined },
     isOwnedBy: function () { return false },
   }
 
@@ -228,6 +235,11 @@ export function createMockCtx(opts) {
           listModels: async function (p) { llmCalls.listModels.push(p); return [] },
         }
       }
+      if (name === 'sessionPersistence') {
+        return {
+          stat: async function (id) { var h = persistedHeaders[id]; return h ? { header: h } : undefined },
+        }
+      }
       return undefined
     },
     effect: function (fn) {
@@ -260,6 +272,8 @@ export function createMockCtx(opts) {
     spSections: spSections,
     llm: llmCalls,
     actor: sid,
+    setRoots: function (list) { rootsList = list || [] }, // 清空/改写活跃 root 集（模拟休眠/重建窗口）
+    persistedHeaders: persistedHeaders, // 持久会话表（sid → { id, parentSession }）；写 parentSession 模拟子会话
 
     // 以真 RPC 语义调用捕获的 webServer 路由（POST /dsh-agent-board → readBody → handlers[method]）
     rpc: async function (method, args) {

package/test/integration.test.mjs

@@ -504,3 +504,40 @@ test('集成i·孤儿回收：in-progress 无活跃 rec 的卡推进时钟后回
     assert.equal(env.sent.length, 0, '孤儿回收的系统通知攒在 sysNotesBuf 等回执冲刷，不单独投递')
   } finally { await env.cleanup() }
 })
+
+// ===== 场景 j：归档数据源全量——老归档（>7 天）与仪表盘同口径，get-tasks 全量返回 =====
+// 归档 tab 空 vs 仪表盘 68 的根因锁定（反馈 n-muyg3e0m9z7i）：归档 tab 数据源必须与仪表盘「已归档」
+// 计数同源（state.tasks 全量，无 7 日窗口、无字段缺失）。host 侧 get-tasks 本就返回全量含归档，
+// 本用例锁死这条数据源契约：建卡→resolve→archive（含 archivedAt>7 天前构造）→断言归档数据源含该卡。
+test('集成j·归档数据源全量：老归档(>7天)与仪表盘同口径，get-tasks 返回全部归档', async () => {
+  var env = createMockCtx()
+  try {
+    plugin.apply(env.ctx)
+    // 新归档 + 老归档各一张：先建卡再 resolve 再 archive（省去派发链路，直接走到可归档态）
+    await createTask(env, 'task-j1', { pipeline: 'work' })
+    await createTask(env, 'task-j2', { pipeline: 'work' })
+    env.patchBoard(function (d) {
+      d.tasks.forEach(function (t) { if (t.id === 'task-j1' || t.id === 'task-j2') { t.status = 'resolved'; t.resolvedAt = new Date(Date.now() - 86400000).toISOString() } })
+    })
+    var a1 = await env.rpc('archive-task', { sessionId: env.sid, taskId: 'task-j1' })
+    var a2 = await env.rpc('archive-task', { sessionId: env.sid, taskId: 'task-j2' })
+    assert.equal(a1.ok, true, 'task-j1 可归档')
+    assert.equal(a2.ok, true, 'task-j2 可归档')
+    // 构造老归档：task-j1 归档于 20 天前（>7 天），task-j2 归档于现在
+    env.patchBoard(function (d) {
+      var j1 = d.tasks.find(function (x) { return x.id === 'task-j1' })
+      j1.archivedAt = new Date(Date.now() - 20 * 86400000).toISOString()
+    })
+    // 归档数据源（get-tasks 全量）：两张归档都在，老归档（>7 天）不被窗口滤掉
+    var d = await env.rpc('get-tasks', { sessionId: env.sid, includeArchived: true })
+    var arch = d.tasks.filter(function (t) { return t.status === 'archived' })
+    assert.equal(arch.length, 2, '归档数据源含全部归档（全量，无 7 日窗口）')
+    assert.ok(arch.some(function (t) { return t.id === 'task-j1' && new Date(Date.now()) - new Date(t.archivedAt) > 7 * 86400000 }), '老归档（>7 天）仍在归档数据源')
+    assert.ok(arch.some(function (t) { return t.id === 'task-j2' }), '新归档也在归档数据源')
+    // 归档字段完整：archivedAt 已落卡（客户端按归档时间倒序的数据源字段不缺）
+    assert.ok(arch.every(function (t) { return !!t.archivedAt }), '每张归档卡都带 archivedAt')
+    // 与仪表盘口径一致：仪表盘「已归档」= state.tasks 里 status==='archived' 的计数，二者同源同值
+    var d2 = await env.rpc('get-tasks', { sessionId: env.sid })
+    assert.equal(d2.tasks.filter(function (t) { return t.status === 'archived' }).length, 2, '无 includeArchived 时同样全量（与仪表盘计数同源）')
+  } finally { await env.cleanup() }
+})

package/test/quality-alert-digest.test.mjs

@@ -0,0 +1,128 @@
+// dsh-agent-board — 异常驱动审视②③：质量异动告警 + 报告导出批次 digest 单测（test/quality-alert-digest.test.mjs，task-muysyad1）
+// 覆盖（对应任务断言①~④ + 接线）：
+//   ② 质量异动告警 qualityChangeHints（scoreboard.trends 环比）
+//     ① 阈值边界——一次通过率恰好 10pp 跌不亮 / 10.1pp 跌亮
+//     ② 样本不足——任一侧 <5 不亮（即便跌幅巨大）；恰好 5/5 判
+//     ③ 超时率/驳回率突变同构各一条（涨 >10pp 亮）；三条同命全出；empty/null/脏输入全形态不炸
+//   ③ 报告导出 buildReport「## 批次摘要（近 24 小时）」段（client 无渲染 harness，源码级断言）：
+//     字段齐全 + 无数据优雅空态 + 产物重组装
+//   ④ 接线 + README 双份——usage/rpc/index 挂 qualityChangeHints + rejectByDay + README 各补一句
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { qualityChangeHints, QUALITY_CHANGE_PP, QUALITY_MIN_SAMPLE, QUALITY_WINDOW_DAYS } from '../index.mjs'
+import { localDayKey } from '../lib/usage.mjs'
+
+// 固定「今天」= 2026-10-30 12:00（本地）：近 7 天 = 10-24..10-30，再前 7 天 = 10-17..10-23
+const NOW = new Date(2026, 9, 30, 12, 0, 0).getTime()
+function dayOf(y, m, d) { return localDayKey(new Date(y, m - 1, d, 12)) }
+const NEAR = dayOf(2026, 10, 30)  // 近窗口某日
+const PRIOR = dayOf(2026, 10, 20) // 前窗口某日
+
+// ===== ②① 阈值边界 =====
+test('②① 阈值边界：一次通过率恰好 10pp 跌不亮 / 10.1pp 跌亮（常量置顶核对）', () => {
+  assert.equal(QUALITY_CHANGE_PP, 10)
+  assert.equal(QUALITY_MIN_SAMPLE, 5)
+  assert.equal(QUALITY_WINDOW_DAYS, 7)
+  // 恰好 10pp：近 90%（900/1000）vs 前 100%（1000/1000）→ drop 10.0pp → 不亮
+  const exact = { trends: { firstPassByDay: { [NEAR]: { resolved: 1000, firstPass: 900 }, [PRIOR]: { resolved: 1000, firstPass: 1000 } }, timeoutByDay: {}, rejectByDay: {} } }
+  assert.deepEqual(qualityChangeHints(exact, NOW), [])
+  // 10.1pp：近 89.9%（899/1000）vs 前 100% → drop 10.1pp → 亮，文案逐字核对
+  const over = { trends: { firstPassByDay: { [NEAR]: { resolved: 1000, firstPass: 899 }, [PRIOR]: { resolved: 1000, firstPass: 1000 } }, timeoutByDay: {}, rejectByDay: {} } }
+  const h = qualityChangeHints(over, NOW)
+  assert.equal(h.length, 1)
+  assert.equal(h[0].level, 'warn')
+  assert.match(h[0].text, /质量异动：一次通过率本周 90%（上周 100%），建议抽查近期验收/)
+})
+
+// ===== ②② 样本不足 =====
+test('②② 样本不足：任一侧 <5 不亮（即便 0% vs 100%）；恰好 5/5 判', () => {
+  // 双侧皆 4（<5）→ 不亮
+  const s = { trends: { firstPassByDay: { [NEAR]: { resolved: 4, firstPass: 0 }, [PRIOR]: { resolved: 4, firstPass: 4 } }, timeoutByDay: {}, rejectByDay: {} } }
+  assert.deepEqual(qualityChangeHints(s, NOW), [])
+  // 仅一侧不足（近 5 / 前 4）→ 不亮
+  const s2 = { trends: { firstPassByDay: { [NEAR]: { resolved: 5, firstPass: 0 }, [PRIOR]: { resolved: 4, firstPass: 4 } }, timeoutByDay: {}, rejectByDay: {} } }
+  assert.deepEqual(qualityChangeHints(s2, NOW), [])
+  // 恰好 5/5 且大幅跌 → 亮（护栏边界：恰好 5 判，非 5 不判）
+  const s3 = { trends: { firstPassByDay: { [NEAR]: { resolved: 5, firstPass: 0 }, [PRIOR]: { resolved: 5, firstPass: 5 } }, timeoutByDay: {}, rejectByDay: {} } }
+  assert.equal(qualityChangeHints(s3, NOW).length, 1)
+})
+
+// ===== ②③ 超时率/驳回率同构 + 空形态 =====
+test('②③ 超时率/驳回率突变同构各一条 + 三规则同命全出 + empty/null/脏输入不炸', () => {
+  // 超时率涨：近 20%（20/100）vs 前 5%（5/100）→ 涨 15pp → 亮
+  const to = { trends: { firstPassByDay: {}, timeoutByDay: { [NEAR]: { runs: 100, timeout: 20 }, [PRIOR]: { runs: 100, timeout: 5 } }, rejectByDay: {} } }
+  const ht = qualityChangeHints(to, NOW)
+  assert.equal(ht.length, 1)
+  assert.match(ht[0].text, /质量异动：超时率本周 20%（上周 5%），建议排查派发\/超时链路/)
+  // 驳回率涨：近 20 次驳回 / 前 5 次（分母 runs 各 100）→ 涨 15pp → 亮
+  const rj = { trends: { firstPassByDay: {}, timeoutByDay: { [NEAR]: { runs: 100, timeout: 0 }, [PRIOR]: { runs: 100, timeout: 0 } }, rejectByDay: { [NEAR]: { rejects: 20 }, [PRIOR]: { rejects: 5 } } } }
+  const hr = qualityChangeHints(rj, NOW)
+  assert.equal(hr.length, 1)
+  assert.match(hr[0].text, /质量异动：驳回率本周 20%（上周 5%），建议审查近期驳回原因/)
+  // 三条规则同时命中 → 三条全出（一次通过率 + 超时率 + 驳回率）
+  const all3 = { trends: { firstPassByDay: { [NEAR]: { resolved: 100, firstPass: 0 }, [PRIOR]: { resolved: 100, firstPass: 100 } }, timeoutByDay: { [NEAR]: { runs: 100, timeout: 50 }, [PRIOR]: { runs: 100, timeout: 0 } }, rejectByDay: { [NEAR]: { rejects: 50 }, [PRIOR]: { rejects: 0 } } } }
+  assert.equal(qualityChangeHints(all3, NOW).length, 3)
+  // empty/null/脏输入全形态不炸（老 host 缺 trends / rejectByDay 等）
+  assert.deepEqual(qualityChangeHints(null, NOW), [])
+  assert.deepEqual(qualityChangeHints({}, NOW), [])
+  assert.deepEqual(qualityChangeHints({ trends: {} }, NOW), [])
+  assert.deepEqual(qualityChangeHints({ trends: 'garbage' }, NOW), [])
+  assert.deepEqual(qualityChangeHints({ buckets: [] }, NOW), [])
+  // 缺 rejectByDay（老 host）只有超时率规则可判，驳回率规则静默跳过不炸
+  const noRj = { trends: { firstPassByDay: {}, timeoutByDay: { [NEAR]: { runs: 100, timeout: 30 }, [PRIOR]: { runs: 100, timeout: 0 } } } }
+  const hnr = qualityChangeHints(noRj, NOW)
+  assert.equal(hnr.length, 1)
+  assert.match(hnr[0].text, /质量异动：超时率本周/)
+})
+
+// ===== ③ 报告导出「批次摘要」段（源码级）=====
+test('③ 报告段：buildReport「## 批次摘要（近 24 小时）」字段齐全 + 无数据优雅空态 + 产物重组装', () => {
+  const dash = readFileSync(new URL('../lib/client/dashboard.js', import.meta.url), 'utf8')
+  const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+  // 段标题 + 五字段（完成/驳回/Token/异常事件/质量趋势）+ 无数据优雅空态
+  assert.ok(dash.indexOf('## 批次摘要（近 24 小时）') >= 0, '报告缺批次摘要段标题')
+  assert.ok(dash.indexOf('- 完成：') >= 0, '缺「完成」字段')
+  assert.ok(dash.indexOf('- 驳回：') >= 0, '缺「驳回」字段')
+  assert.ok(dash.indexOf('- Token：约 ') >= 0, '缺「Token」字段')
+  assert.ok(dash.indexOf('- 异常事件：超时 ') >= 0, '缺「异常事件」字段')
+  assert.ok(dash.indexOf('· 幽灵回收 ') >= 0, '缺「幽灵回收」字段')
+  assert.ok(dash.indexOf('- 质量趋势：') >= 0, '缺「质量趋势」字段')
+  assert.ok(dash.indexOf('近 24 小时无活动记录（无完成 / 驳回 / 消耗 / 异常事件）') >= 0, '缺无数据优雅空态')
+  assert.ok(dash.indexOf('function batchDigest()') >= 0, '缺 batchDigest 数据源')
+  // 纯聚合现有字段（不新建 host 状态、不重拉）：run 级 token 现算 + healthHints 读幽灵回收
+  assert.match(dash, /r\.usage && typeof r\.usage === 'object'/)
+  assert.ok(dash.indexOf('本轮回收') >= 0, '缺幽灵回收 healthHints 读取')
+  // 产物重组装：关键标记逐一出现在 lib/client.js
+  for (const m of ['## 批次摘要（近 24 小时）', '近 24 小时无活动记录', 'function batchDigest()']) {
+    assert.ok(built.indexOf(m) >= 0, 'client.js 缺标记：' + m + '（需 npm run build-client 重组装）')
+  }
+})
+
+// ===== ④ 接线 + README 双份 =====
+test('④ 接线：usage/rpc/index 挂 qualityChangeHints + rejectByDay；README 双份逐字一致 + 各补一句', () => {
+  const rpc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
+  const usage = readFileSync(new URL('../lib/usage.mjs', import.meta.url), 'utf8')
+  const idx = readFileSync(new URL('../index.mjs', import.meta.url), 'utf8')
+  // usage.mjs：质量异动常量置顶 + 函数 + rejectByDay 数据源
+  assert.match(usage, /export var QUALITY_CHANGE_PP = 10/)
+  assert.match(usage, /export var QUALITY_MIN_SAMPLE = 5/)
+  assert.match(usage, /export var QUALITY_WINDOW_DAYS = 7/)
+  assert.match(usage, /export function qualityChangeHints\(sb, now\)/)
+  assert.match(usage, /rejectByDay: \{\}/)
+  assert.match(usage, /tr\.rejectByDay\[rcj\.mDay\]/)
+  // rpc：import + healthHints 拼 qualityChangeHints（scoreboard 就位后现算，在 modelPerfHint 之后）
+  assert.match(rpc, /modelPerfHint, qualityChangeHints \} from '\.\/usage\.mjs'/)
+  const iQch = rpc.indexOf('var __qch = qualityChangeHints(d.usageSummary.scoreboard)')
+  const iMph = rpc.indexOf('var __mph = modelPerfHint(d.usageSummary.scoreboard)')
+  assert.ok(iQch >= 0 && iMph >= 0 && iQch > iMph, 'qualityChangeHints 必须在 modelPerfHint 之后现算')
+  assert.match(rpc, /d\.healthHints = __rh\.hints\.concat\(computeHealthHints\(d\.tasks\)\)\.concat\(__qch\)\.concat\(__mph \? \[__mph\] : \[\]\)/)
+  // index 兼容 re-export
+  assert.match(idx, /qualityChangeHints, QUALITY_CHANGE_PP, QUALITY_MIN_SAMPLE, QUALITY_WINDOW_DAYS/)
+  // README 双份：逐字一致 + 各补一句（质量异动 / 批次摘要）
+  const r1 = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8')
+  const r2 = readFileSync(new URL('../README.md', import.meta.url), 'utf8')
+  assert.equal(r1, r2, 'README 双份必须逐字一致（npm run sync-readme）')
+  assert.ok(r1.indexOf('质量异动') >= 0, 'README 缺「质量异动」说明')
+  assert.ok(r1.indexOf('批次摘要') >= 0, 'README 缺「批次摘要」说明')
+})

package/test/review-hints.test.mjs

@@ -0,0 +1,170 @@
+// dsh-agent-board — 风险队列「待你过目」+ 审视摘要区单测（test/review-hints.test.mjs，task-muzikj1y）
+// 覆盖（对应任务断言①~⑥ + 接线）：
+//   ① 四硬信号各命中/不命中（computeReviewHints：驳回/歧义/核心 touches/full 无 acceptance）
+//   ② 软信号平时不计 / 质量异动告警激活期间计入（diff>300 行 + 续跑≥2 次，联动加严）
+//   ③ reviewedAt 幂等落账（mark-reviewed RPC 只写一次）+ get-tasks 现算透出 reviewHint 零落库
+//   ④⑤ 客户端接线（徽章/chip/审视摘要区四块+来源徽标/digest 未过目）源码级 + 产物重组装
+//   ⑥ README 双份逐字一致 + 各补「待你过目」说明
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import * as core from '../lib/core.mjs'
+import { createMockCtx } from './helpers/mock-ctx.mjs'
+import * as plugin from '../index.mjs'
+
+// 纯函数测试的任务形态：默认「干净卡」（无驳回/无歧义/无核心 touches/有 acceptance）→ score 0
+function mkTask(over) {
+  return Object.assign({ id: 't1', title: 'T', status: 'resolved', pipeline: 'full', acceptance: 'npm test', touches: [], messages: [], runs: [], rejectCount: 0 }, over || {})
+}
+
+// ===== ① 四硬信号各命中/不命中 =====
+test('① 四硬信号各命中/不命中（computeReviewHints）', () => {
+  // 干净卡 → score 0
+  assert.deepEqual(core.computeReviewHints([mkTask()]), { t1: { score: 0, reasons: [] } })
+  // 硬① 被驳回过：rejectCount>0（canonical 口径）
+  var h1 = core.computeReviewHints([mkTask({ id: 'a', rejectCount: 1 })])
+  assert.equal(h1.a.score, 1); assert.match(h1.a.reasons[0], /驳回/)
+  // 硬① 备选：verification.verdict='rejected'
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', verification: { verdict: 'rejected' } })]).a.score, 1)
+  // 硬① 备选：messages kind='rejection'
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', messages: [{ kind: 'rejection', text: 'x' }] })]).a.score, 1)
+  // 硬① 备选：runs 含 rejected 结局（老留档兼容，字面「runs 含 rejected」口径）
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', runs: [{ outcome: 'rejected' }] })]).a.score, 1)
+  // 硬① 不命中：零驳回
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', rejectCount: 0, verification: { verdict: 'approved' } })]).a.score, 0)
+  // 硬② 上报过歧义：messages kind='arbitration'
+  var h2 = core.computeReviewHints([mkTask({ id: 'a', messages: [{ kind: 'arbitration', text: 'x' }] })])
+  assert.equal(h2.a.score, 1); assert.match(h2.a.reasons[0], /歧义/)
+  // 硬② 不命中：无 arbitration 包
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', messages: [{ kind: 'progress', text: 'x' }] })]).a.score, 0)
+  // 硬③ touches 碰核心文件：三种核心文件 basename 各命中
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', touches: ['lib/dispatch.mjs'] })]).a.score, 1)
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', touches: ['lib/rpc.mjs'] })]).a.score, 1)
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', touches: ['core.mjs'] })]).a.score, 1)
+  assert.match(core.computeReviewHints([mkTask({ id: 'a', touches: ['./lib/core.mjs'] })]).a.reasons[0], /核心文件/)
+  // 硬③ 不命中：非核心文件 / glob
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', touches: ['src/a.mjs'] })]).a.score, 0)
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', touches: ['*.mjs'] })]).a.score, 0)
+  // 硬④ full 无 acceptance
+  var h4 = core.computeReviewHints([mkTask({ id: 'a', acceptance: '' })])
+  assert.equal(h4.a.score, 1); assert.match(h4.a.reasons[0], /验收脚本/)
+  // 硬④ 不命中：有 acceptance / work 档 / 空白 acceptance 但有内容（trim 后非空不算空）
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', acceptance: 'node --test' })]).a.score, 0)
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', acceptance: '', pipeline: 'work' })]).a.score, 0)
+})
+
+// ===== ② 软信号：平时不计 / 告警态计入（联动加严）=====
+test('② 软信号：质量异动告警未激活不计入 / 激活期间计入（diff>300 行 + 续跑≥2 次）', () => {
+  var diff = ' src/a.mjs | 200 +++++++\n 1 file changed, 350 insertions(+), 50 deletions(-)'
+  var t = mkTask({ id: 'a', deliverable: { diff: diff }, runs: [{ role: 'worker', resume: true }, { role: 'worker', resume: true }] })
+  // 平时（告警未激活）：软信号不计入 → score 0
+  assert.equal(core.computeReviewHints([t], {}).a.score, 0)
+  assert.equal(core.computeReviewHints([t], { qualityAlertActive: false }).a.score, 0)
+  // 告警激活：diff(400 行)>300 + 续跑 2 次≥2 → 两条软信号全计入
+  var h = core.computeReviewHints([t], { qualityAlertActive: true })
+  assert.equal(h.a.score, 2)
+  assert.match(h.a.reasons[0], /diff 超 300 行/)
+  assert.match(h.a.reasons[1], /续跑 ≥2 次/)
+  // 阈值边界：恰好 300 行不亮（>300 才亮）；续跑 1 次不亮
+  var diffEdge = ' 1 file changed, 250 insertions(+), 50 deletions(-)' // 300 行
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', deliverable: { diff: diffEdge } })], { qualityAlertActive: true }).a.score, 0)
+  assert.equal(core.computeReviewHints([mkTask({ id: 'a', runs: [{ resume: true }] })], { qualityAlertActive: true }).a.score, 0)
+  // 硬软叠加：硬④ + 软⑤ + 软⑥ → score 3
+  var tMix = mkTask({ id: 'a', acceptance: '', deliverable: { diff: diff }, runs: [{ resume: true }, { resume: true }] })
+  var hMix = core.computeReviewHints([tMix], { qualityAlertActive: true })
+  assert.equal(hMix.a.score, 3)
+})
+
+// ===== ③ reviewedAt 幂等落账 + get-tasks 现算透出 reviewHint（真 harness）=====
+test('③ mark-reviewed 幂等落账（只写一次）+ get-tasks 现算透出 reviewHint 零落库', async () => {
+  var env = createMockCtx()
+  try {
+    plugin.apply(env.ctx)
+    await env.rpc('create-task', { sessionId: env.sid, id: 'task-rv', title: 'R', description: 'd', pipeline: 'full', acceptance: 'npm test' })
+    assert.equal(env.task('task-rv').reviewedAt, undefined, '初始无 reviewedAt')
+    // 第一次落账
+    var r1 = await env.rpc('mark-reviewed', { sessionId: env.sid, taskId: 'task-rv' })
+    assert.equal(r1.ok, true)
+    var at1 = env.task('task-rv').reviewedAt
+    assert.ok(at1, '第一次落账 reviewedAt')
+    // 幂等：第二次不重写
+    var r2 = await env.rpc('mark-reviewed', { sessionId: env.sid, taskId: 'task-rv' })
+    assert.equal(r2.ok, true)
+    assert.equal(env.task('task-rv').reviewedAt, at1, '第二次调用不重写 reviewedAt')
+    // 未找到任务
+    var r3 = await env.rpc('mark-reviewed', { sessionId: env.sid, taskId: 'nope' })
+    assert.equal(r3.ok, false)
+    // get-tasks 透出 reviewHint（现算，不落盘）
+    await env.rpc('create-task', { sessionId: env.sid, id: 'task-gh', title: 'G', description: 'd', pipeline: 'full', acceptance: 'npm test' })
+    env.patchBoard(function (d) {
+      var t = d.tasks.find(function (x) { return x.id === 'task-gh' })
+      t.rejectCount = 1
+      t.touches = ['lib/core.mjs']
+      t.acceptance = ''
+    })
+    var d = await env.rpc('get-tasks', { sessionId: env.sid })
+    var gh = d.tasks.find(function (x) { return x.id === 'task-gh' })
+    assert.ok(gh.reviewHint, 'get-tasks 透出 reviewHint')
+    assert.equal(gh.reviewHint.score, 3, '驳回 + 核心文件 + 无 acceptance = 3 条硬信号')
+    assert.equal(gh.reviewHint.reasons.length, 3)
+    // 零落库：board 文件不存 reviewHint（现算字段不进盘）
+    var raw = env.board().tasks.find(function (x) { return x.id === 'task-gh' })
+    assert.equal(raw.reviewHint, undefined, 'reviewHint 现算零落库（board 文件不写 reviewHint）')
+  } finally { await env.cleanup() }
+})
+
+// ===== ④⑤⑥ 客户端接线 + 产物重组装 + README 双份（源码级）=====
+test('④⑤ 客户端接线：徽章/chip/审视摘要区四块+来源徽标/digest（源码级 + 产物重组装）', () => {
+  const ksrc = readFileSync(new URL('../lib/client/kernel.js', import.meta.url), 'utf8')
+  const bl = readFileSync(new URL('../lib/client/board-list.js', import.meta.url), 'utf8')
+  const td = readFileSync(new URL('../lib/client/task-detail.js', import.meta.url), 'utf8')
+  const dash = readFileSync(new URL('../lib/client/dashboard.js', import.meta.url), 'utf8')
+  const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
+  // kernel：单一事实源谓词 + 过滤接线 + state 默认字段
+  assert.match(ksrc, /function reviewPending\(t\)/)
+  assert.match(ksrc, /state\.filterReview && !reviewPending\(t\)/)
+  assert.match(ksrc, /filterReview: false/)
+  // board-list：chip「待你过目」+ 「建议过目」徽章
+  assert.ok(bl.indexOf('待你过目') >= 0, 'FilterBar 缺「待你过目」chip')
+  assert.ok(bl.indexOf('👁 建议过目') >= 0, '缺「建议过目」徽章')
+  assert.match(bl, /reviewPending\(t\) \?/)
+  // task-detail：审视摘要区四块 + 来源徽标 + mark-reviewed 触发
+  assert.ok(td.indexOf('tskb-review-summary') >= 0, '缺审视摘要区容器 id')
+  assert.ok(td.indexOf('① 为什么在这') >= 0, '缺四问①')
+  assert.ok(td.indexOf('② 改了什么') >= 0, '缺四问②')
+  assert.ok(td.indexOf('③ 机器怎么验的') >= 0, '缺四问③')
+  assert.ok(td.indexOf('④ 怎么亲自确认') >= 0, '缺四问④')
+  assert.ok(td.indexOf('Worker 汇报') >= 0, '缺「Worker 汇报」来源徽标')
+  assert.ok(td.indexOf('Verifier 实证') >= 0, '缺「Verifier 实证」来源徽标')
+  assert.ok(td.indexOf('系统记录') >= 0, '缺「系统记录」来源徽标')
+  assert.match(td, /rpc\('mark-reviewed'/)
+  // dashboard：digest 未过目计数 + buildReport 行
+  assert.match(dash, /reviewPending\(t\)/)
+  assert.ok(dash.indexOf('- 未过目：') >= 0, '报告缺「未过目」行')
+  // 产物重组装：关键标记逐一出现在 lib/client.js
+  for (const m of ['待你过目', '👁 建议过目', 'tskb-review-summary', '- 未过目：']) {
+    assert.ok(built.indexOf(m) >= 0, 'client.js 缺标记：' + m + '（需 npm run build-client 重组装）')
+  }
+})
+
+test('接线：core 纯函数 + rpc get-tasks 现算 + mark-reviewed（源码级）', () => {
+  const rpc = readFileSync(new URL('../lib/rpc.mjs', import.meta.url), 'utf8')
+  const coreSrc = readFileSync(new URL('../lib/core.mjs', import.meta.url), 'utf8')
+  assert.match(coreSrc, /export function computeReviewHints\(tasks, opts\)/)
+  assert.match(coreSrc, /export var REVIEW_CORE_FILES = \['dispatch\.mjs', 'rpc\.mjs', 'core\.mjs'\]/)
+  assert.match(rpc, /core\.computeReviewHints\(d\.tasks, \{ qualityAlertActive: __qch\.length > 0 \}\)/)
+  assert.match(rpc, /handle\('mark-reviewed'/)
+  assert.match(rpc, /if \(!t\.reviewedAt\) t\.reviewedAt = new Date\(\)\.toISOString\(\)/)
+  // tasksHash 序列化口径纳入 reviewedAt + reviewHint（已阅/软信号联动才能重渲染）
+  assert.match(coreSrc, /t\.reviewedAt,/)
+  assert.match(coreSrc, /t\.reviewHint \? String\(t\.reviewHint\.score\)/)
+})
+
+test('⑥ README 双份：逐字一致 + 各补「待你过目」说明', () => {
+  const r1 = readFileSync(new URL('../../../README.md', import.meta.url), 'utf8')
+  const r2 = readFileSync(new URL('../README.md', import.meta.url), 'utf8')
+  assert.equal(r1, r2, 'README 双份必须逐字一致（npm run sync-readme）')
+  assert.ok(r1.indexOf('待你过目') >= 0, 'README 缺「待你过目」说明')
+  assert.ok(r1.indexOf('审视摘要') >= 0, 'README 缺「审视摘要」说明')
+  assert.ok(r1.indexOf('reviewHint') >= 0, 'README 缺 reviewHint 说明')
+})

package/test/scorecard-clusters.test.mjs

@@ -192,11 +192,11 @@ test('卡5⑤b：接线（源码级）——rpc healthHints 拼 modelPerfHint /
   const dash = readFileSync(new URL('../lib/client/dashboard.js', import.meta.url), 'utf8')
   const built = readFileSync(new URL('../lib/client.js', import.meta.url), 'utf8')
   // host：modelPerfHint 从 usage.mjs import；scoreboard 就位后现算；拼在 computeHealthHints 结果尾部
-  assert.match(rpc, /import \{ findRunLog, readLogBytes, readLogFrames, aggregateUsageSummary, readMainWindowUsage, buildScoreboard, modelPerfHint \} from '\.\/usage\.mjs'/)
+  assert.match(rpc, /import \{ findRunLog, readLogBytes, readLogFrames, aggregateUsageSummary, readMainWindowUsage, buildScoreboard, modelPerfHint, qualityChangeHints \} from '\.\/usage\.mjs'/)
   const iSb = rpc.indexOf('d.usageSummary.scoreboard = buildScoreboard(d.tasks, args && args.range')
   const iMph = rpc.indexOf('var __mph = modelPerfHint(d.usageSummary.scoreboard)')
   assert.ok(iSb >= 0 && iMph > iSb, 'modelPerfHint 必须在 scoreboard 挂载之后现算')
-  assert.match(rpc, /d\.healthHints = __rh\.hints\.concat\(computeHealthHints\(d\.tasks\)\)\.concat\(__mph \? \[__mph\] : \[\]\)/)
+  assert.match(rpc, /d\.healthHints = __rh\.hints\.concat\(computeHealthHints\(d\.tasks\)\)\.concat\(__qch\)\.concat\(__mph \? \[__mph\] : \[\]\)/)
   // usage.mjs：聚类规则表 / 聚类函数 / hint 阈值常量导出
   assert.match(usage, /export var REJECTION_CLUSTER_RULES = \[/)
   assert.match(usage, /export function clusterRejections\(texts\)/)

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

@@ -0,0 +1,112 @@
+// 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 path from 'node:path'
+import { createMockCtx } from './helpers/mock-ctx.mjs'
+import * as plugin from '../index.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() }
+})