@moonquake2004/dsh-doctor 0.7.2 → 0.8.1

package/CHANGELOG.md

@@ -16,6 +16,78 @@
 
 ---
 
+## [0.8.1] — 2026-09-16
+
+### 0.8.0 的回归审计 —— **修一个引入一个，被查出来了四个**
+
+对 0.8.0 做回归审计（R12/R13），确认它**引入了新问题**：
+
+| 引入的问题 | 现象 | 修法 |
+|---|---|---|
+| **覆盖量上下文跨段泄漏** | 会话段的 S6/S14 号称"检查了 **16 个 bundle 条目**"，而它们实际展开的是 **11352 个事件** —— 伪造的数字比没有数字更危险，因为它看起来可信 | 段边界 `resetCoverage()` + **单位属于求值阶段**（新增 `phase` 字段）；回归测试断言"单位不得串台" |
+| **目录段继承会话单位** | 目录检查 `P6-patch-name-space`（section=profile）声称"检查了会话日志" | catalog 阶段独立单位（`目录检查项`） |
+| **R6 只校验类型、不校验个数** | JS 静默忽略多余参数 → 我给 S11 补覆盖量时多传一个 `undefined`，**没人报错**（类型守卫也抓不到） | `report()` 增加**参数个数守卫**（>7 即抛） |
+| **两处测试自伤** | 抽取 `report` 的测试缺 `currentPhase` 桩；清单需重新生成 | 已修 |
+
+### Added — 论坛病例语料（`plugin/test/forum-cases.test.mjs`）
+
+把社区**实际报告的问题**做成回归用例（R2 样本律），每例都配**健康对照**，同时防漏报与误报：
+
+| 病例 | 出处 | 结果 |
+|---|---|---|
+| 缺 `dsh.bundle` → `--boot-check` 必须失败 | #6788 | ✓ 通过（含对照） |
+| manifest 带 BOM → P15 报出且其余检查仍运行 | #6758 | ✓ 通过（含对照） |
+| 迁移后缺 `data.message` → S14 报出 | #6686 | ✓ 通过（含对照） |
+| 裸引用 `harness`/`styles` → P21 失败 | #6693 规则2/4 | ✓ 通过（含注释/字符串对照） |
+| client 产物写成裸 ESM → P20 报出 | #6693 规则3 | ✓ 通过（含对照） |
+| `apply()` 期抛错 | #6693 规则1 | **已知不能检出**：我们只到 import 层，判定仍是 loadable —— 作为**边界用例**钉在测试里，防止把"P20/P21 通过"误读成"一定能起来" |
+| 损坏的 `.zstd` → 判为损坏而非"读取不稳" | #6739 | ✓ 通过。**仅损坏一侧可验证**：报告者的"失败帧偏移每次不同"（读取路径不稳）无法在测试里忠实复现，已在用例注释里写明 |
+
+**写这个语料时我又犯了一次 R9**：病例 G 的 fixture 我写成两层目录，而真实布局是三层
+（`sessions/<项目>/<会话>/<日志>`）→ 定位器找不到 → S11 报"未发现会话日志"。**那是 fixture 失真，不是漏报** ——
+修成真实布局后，S11 正确报出"1 个损坏会话…3 次尝试均失败 → 倾向于文件本身损坏"。
+
+测试 129 → 141（+12 论坛病例）；审计 **8/8**。
+
+## [0.8.0] — 2026-09-16
+
+### 结构性修复：假绿灯的**类**被消灭，而不是又一个实例
+
+用户指出：**刚复查过又犯错，说明规则本身有缺陷**。复查确认了缺陷的性质——**R3 的强制点选错了**：
+它被写在 `report()` 里，而判定并不都在那里产生。机械枚举（而非凭记忆）发现 **21 处代码位置手写 ✓/⊖/✗**，
+其中我只加固过 3 处；另外两处从未查过：
+
+| 位置 | 修前行为 |
+|---|---|
+| `--boot-check` | 零对象仍打印"✓ 所有可探测 entry 均可导入" |
+| `--safe-add` | 零对象 `ok:true, stage:'verified'` **并写"已知良好"快照**（把"未验证"固化成"已验证"） |
+| `--post-upgrade` | 同样打印"✓ 装载模拟通过"并写快照 |
+| **顶层聚合** | 极简 PATH 下 18 skip / 2 pass，仍打印 **"✓ 全部通过"**（从未查过） |
+| **JSON 形态** | `ok: true` 只要求"无失败"，"全部跳过"也算通过 |
+
+**改为收口点结构**（R10 边界律 + R11 闭集律）：
+
+- **`makeVerdict(state, opts)`** —— 唯一能构造 `pass` 的地方；`checked === 0` 时**构造期即抛错**（不是渲染期补救）；
+- **`printVerdict()` / `printItem()` / `VERDICT_MARKS`** —— **唯一**打印 `✓/⊖/✗` 的三个位置，
+  调用点传**状态名**而不是符号（于是符号泄漏在结构上不可能）；
+- **`aggregateVerdict()`** —— 聚合判定如实给出 `verified / skipped / failed`：
+  全部跳过时输出 `⊖ 没有任何检查实际验证过（N 项全部跳过）——这不等于通过`；
+  有跳过时输出 `✓ N 项通过、M 项未检查（skip）——未检查的部分不代表通过`；
+- **JSON 契约收紧**：`ok` 只有在**确实验证过（verified > 0）且无失败**时才为 true，并新增
+  `verified / skipped / failed` 三个字段。
+
+### Added — 审计与规则的机制化
+
+- **`scripts/audit.sh`**（R12 可重审律 / R13 环境泛化律）：一条命令、五个环境、结果可比——
+  空环境 / 极简 PATH（无 dsh、pnpm、zstd）/ 畸形输入（BOM、截断 JSON）/ 清单一致性 / 闭集与全套测试。
+  当前 **7/7 通过**。
+- **闭集测试**（R11）：断言源码中任何 `✓/⊖/✗` 都必须落在三个收口点内——**今后新加一处手写绿灯会直接红**。
+- **规则补 4 条**（`docs/check-authoring-rules.md`）：**R10 边界律**（每条规则必须指明强制点，且是所有同类输出的必经之路）、
+  **R11 闭集律**、**R12 可重审律**、**R13 环境泛化律**；§4 记录本次复查，包括**我在这轮审计里又犯的一次 R8**
+  （审计脚本第一版断言"空环境 verified 必须为 0"，而空 profile 里 P15 确实验证了 3 个文件——断言强度超过了证据）。
+
+测试 124 → 127。
+
 ## [0.7.2] — 2026-09-16
 
 ### 用新规则复查旧错误 —— **确认重复犯了同一个错**

package/dsh-doctor.mjs

@@ -235,12 +235,24 @@ function hasDshEnvironment(home = HOME) {
  */
 let coverageContext = null; // 当前检查段"检查了多少同类对象"的默认值（由 setCoverage 设置）
 function setCoverage(n, what) { coverageContext = typeof n === 'number' ? { n, what } : null; }
+/** 段边界重置：覆盖量上下文**绝不允许跨段继承**——否则会伪造出一个看起来可信的数字。
+ *  2026-09 回归审计实测：会话段的 S6/S14 曾号称"检查了 16 个 bundle 条目"，而它们实际展开的是 11352 个事件。 */
+function resetCoverage() { coverageContext = null; }
+/** 求值阶段（env/profile/session/catalog）。覆盖量的**单位属于阶段**，不属于展示用的 section——
+ *  目录提供的检查会带 section:'env'/'profile'，但它们在 catalog 阶段求值（回归审计实测）。 */
+let currentPhase = null;
+function setPhase(p) { currentPhase = p; }
 function coverageNow() { return coverageContext; }
 
 function report(section, id, ok, detail, fix, src, examined) {
   // R6 接口律：参数放错位置必须**立刻抛**，而不是变成一条静默的错误判定。
   // 来历：我曾在 fix 之后多插了两个参数，结果 'builtin' 落到了 examined 的位置（字符串）→
   // 回退到上下文 0 → 一条本该 pass 的检查被静默降级。凭记忆拼参数是可以通过机制消灭的。
+  // R6 扩展（2026-09 回归审计）：**参数个数**守卫。JS 会静默忽略多余参数，而我只校验了类型——
+  // 于是"多传一个 undefined"这类错误（我给 S11 补覆盖量时就犯了）能一路走到运行时。
+  if (arguments.length > 7) {
+    throw new Error(`report(${id}): 最多 7 个参数 (section, id, ok, detail, fix, src, examined)，收到 ${arguments.length} 个 —— 检查参数位置`);
+  }
   if (typeof examined !== 'number' && examined !== undefined) {
     throw new Error(`report(${id}): examined 必须是 number 或 undefined，收到 ${typeof examined}（${JSON.stringify(examined)}）——检查参数位置`);
   }
@@ -255,7 +267,7 @@ function report(section, id, ok, detail, fix, src, examined) {
     results.push({ section, id, ok: true, skip: true, coverage: 'none', detail: `${detail}（无可检查对象，未做任何比较）`, fix, src: src ?? 'builtin' });
     return;
   }
-  const rec = { section, id, ok, detail, fix, src: src ?? 'builtin' };
+  const rec = { section, id, ok, detail, fix, src: src ?? 'builtin', phase: currentPhase };
   if (ok === true) {
     const ctx = coverageNow();
     const n = typeof examined === 'number' ? examined : ctx?.n;
@@ -270,6 +282,71 @@ function reportSkip(section, id, detail, src) {
   results.push({ section, id, ok: true, skip: true, detail, src: src ?? 'builtin' });
 }
 
+
+/* ================= 判定收口点（R10 边界律 + R11 闭集律） =================
+ * 2026-09 复查的结论：**"绿"此前可以在任意位置被手写出来**，所以 R3 的不变量只要放在
+ * report() 或某个输出路径里，别的路径就能绕过——修了三处、漏了顶层聚合与更新提示。
+ *
+ * 现在：**所有 ✓ / ⊖ / ✗ 只能由 printVerdict() 打印**，而"通过"这个状态只能由 makeVerdict() 构造，
+ * 且 `pass` 在 `checked === 0` 时**直接抛错**（构造期就挡住，而不是渲染期才补救）。
+ * 测试里有一条闭集断言：源码中任何出现 ✓/⊖/✗ 的代码行，都必须落在 printVerdict 的函数体内。
+ */
+
+/**
+ * 构造判定。**唯一能产生 'pass' 的地方**。
+ * @param {'pass'|'fail'|'skip'|'action'} state
+ * @param {{checked?: number, detail?: string, reason?: string, totals?: {verified:number, skipped:number, failed:number}}} opts
+ */
+function makeVerdict(state, opts = {}) {
+  if (state === 'pass') {
+    const n = opts.checked;
+    if (typeof n !== 'number' || n <= 0) {
+      throw new Error(`makeVerdict('pass') 需要 checked > 0：零检查对象不得构造为"通过"（R3 覆盖律；configured=${JSON.stringify(opts.checked)}）`);
+    }
+  }
+  return { state, ...opts };
+}
+
+/**
+ * 条目行打印器：**判定之下的明细**（某条 entry 失败、某个会话损坏……）。
+ * 与 printVerdict 的分工：判定回答"整件事成不成立"，条目回答"具体哪几条"。
+ * 两者构成本工具的**闭集**——闭集测试断言：源码里任何 ✓/⊖/✗ 都必须落在这两个函数体内。
+ */
+const VERDICT_MARKS = { pass: '✓', fail: '✗', skip: '⊖', warn: '⚠', action: '✓' };
+
+function printItem(state, text, indent = 2) {
+  console.log(`${' '.repeat(indent)}${VERDICT_MARKS[state] ?? '?'} ${text}`);
+}
+
+/** **唯一**打印 ✓ / ⊖ / ✗ 的**判定**的地方。任何新输出路径都必须走这里，否则闭集测试会红。 */
+function printVerdict(v, opts = {}) {
+  const out = opts.stream === 'stderr' ? console.error : console.log;
+  const line = (state, text) => out(opts.indent ? `  ${VERDICT_MARKS[state]} ${text}` : `${VERDICT_MARKS[state]} ${text}`);
+  if (v.state === 'pass') return line('pass', v.detail ?? `通过（检查 ${v.checked} 个对象）`);
+  if (v.state === 'fail') return line('fail', v.detail ?? '失败');
+  if (v.state === 'skip') return line('skip', `${v.reason ?? '未检查'}——**这不等于通过**`);
+  return line('action', v.detail ?? ''); // action：动作确认（不是验证断言）
+}
+
+/**
+ * 报告级聚合判定：把"验证过多少 / 跳过多少"如实呈现。
+ * 修前它对"18 项 skip + 2 项 pass"照样打印 "✓ 全部通过"——断言的强度超过了证据（R8）。
+ */
+function aggregateVerdict(records) {
+  const failed = records.filter((r) => !r.skip && !r.ok);
+  const verified = records.filter((r) => !r.skip && r.ok && (r.examined ?? 0) > 0).length;
+  const skipped = records.filter((r) => r.skip).length;
+  const totals = { verified, skipped, failed: failed.length };
+  if (failed.length) return makeVerdict('fail', { totals, detail: `${failed.length} 个问题` });
+  if (verified === 0) {
+    return makeVerdict('skip', { totals, reason: `没有任何检查实际验证过（${skipped} 项全部跳过）` });
+  }
+  if (skipped > 0) {
+    return makeVerdict('pass', { checked: verified, totals, detail: `${verified} 项通过、${skipped} 项未检查（skip）——**未检查的部分不代表通过**` });
+  }
+  return makeVerdict('pass', { checked: verified, totals, detail: `全部通过（${verified} 项，均已验证）` });
+}
+
 /** 解析 --profile 参数：名字（如 web）→ $DSH_HOME/profiles/<name>；含路径分隔符/~/开头 → 直接当 profile 目录（契约 harness 传绝对路径）。 */
 function resolveProfile(name) {
   if (!name) throw new Error('无效 profile 名');
@@ -313,6 +390,8 @@ function nodeInSupportedRange(v, range = NODE_RANGE_FALLBACK) {
   return peerRangeState(String(v).replace(/^v/, ''), range).state === 'satisfied';
 }
 function checkEnv() {
+  setPhase('env');
+  resetCoverage();
   if (!wants('env')) return;
   // R3 覆盖律：环境段的每个探针各检查**一个**对象（某个二进制/版本/端口）。
   // 单位不同的检查（如 E1 系列各自查一个可执行文件）如需别的数量应显式传入。
@@ -602,6 +681,8 @@ function checkProfile(name) {
   }
   const bundles = manifest.dsh?.profile?.bundles ?? [];
   const deps = manifest.dependencies ?? {};
+  setPhase('profile');
+  resetCoverage();               // 段边界：不得继承上一段的覆盖量
   setCoverage(bundles.length, 'bundle 条目');
 
   const installAnchor = (() => {
@@ -1500,6 +1581,9 @@ function latestSessionLog(root = join(HOME, 'sessions')) {
 
 /* ================= session ================= */
 function checkSession(targetPath) {
+  setPhase('session');
+  resetCoverage();
+  setCoverage(1, '会话日志');   // 单位是这一份会话日志；事件数由各检查在 detail 里给出
   if (!wants('session')) return;
   const target = targetPath || latestSessionLog();
   if (!target || !existsSync(target)) { report('session', 'S0', true, '无会话日志，跳过单会话检查（可用 --session <path> 指定）', undefined); return; }
@@ -2008,7 +2092,7 @@ function scanAllSessions() {
   const heapLimit = Number(process.env.DSH_DOCTOR_HEAP_MB || 1024);
   const totalRisk = estHeapMB > heapLimit;
   if (quars.length) {
-    report('session', 'S11', false, `全会话扫描：${corrupt.length} 个损坏会话（#1550：冷打开会拖垮服务器）: ${quars.join(' | ')}`, `隔离：把这些会话目录移出 ${join(HOME, 'sessions')}（如 mv 到备份目录）`);
+    report('session', 'S11', false, `全会话扫描：${corrupt.length} 个损坏会话（#1550：冷打开会拖垮服务器）: ${quars.join(' | ')}`, `隔离：把这些会话目录移出 ${join(HOME, 'sessions')}（如 mv 到备份目录）`, undefined, files.length);
   } else if (oversized.length || totalRisk || unstableReads.length) {
     const parts = [];
     // 间歇性读取失败：**不是文件损坏**（重试即成功、失败帧位置每次不同，见 #6739），
@@ -2020,9 +2104,9 @@ function scanAllSessions() {
     report('session', 'S11', true, `⚠ 全会话扫描：${parts.join('；')}（未损坏，可接受或归档）`,
       unstableReads.length
         ? '间歇性读取失败不是日志问题：先重试读取；持续出现则排查存储健康（SMART）、内存与磁盘驱动（#6739 的证据是失败帧位置每次不同）'
-        : '冷启动会明显变慢；必要时压缩/归档历史会话');
+        : '冷启动会明显变慢；必要时压缩/归档历史会话', undefined, files.length);
   } else {
-    report('session', 'S11', true, `全会话扫描：${clean.length} 个会话均健康（损坏 0 / 超大 0 / 估算物化堆 ${estHeapMB}MB）`, undefined);
+    report('session', 'S11', true, `全会话扫描：${clean.length} 个会话均健康（损坏 0 / 超大 0 / 估算物化堆 ${estHeapMB}MB）`, undefined, undefined, files.length);
   }
 }
 
@@ -2253,6 +2337,11 @@ export function runCatalogCheck(check, ctx) {
 
 /** 逐条执行目录检查，汇入统一 results 管线（src='catalog'）。尊重 --profile/--env/--session 收窄。 */
 function checkCatalog(ctx, catalog) {
+  setPhase('catalog');
+  // 段边界：目录检查在会话段之后求值，若不清空上下文会**继承会话的单位**——
+  // 回归审计实测到 `P6-patch-name-space`(profile) 声称"检查了会话日志"。目录检查各查一个目标，单位独立。
+  resetCoverage();
+  setCoverage(1, '目录检查项');
   const platform = process.platform;
   for (const check of catalog.checks ?? []) {
     if (!wants(check.section)) continue; // 与内置检查一致的 section 收窄
@@ -2887,7 +2976,7 @@ async function run() {
       const base = writePreUpgrade(profDir);
       if (jsonOut) console.log(JSON.stringify({ ok: true, ...base }, null, 2));
       else {
-        console.log(`✓ 已记录升级前基线（${profDir}）`);
+        printVerdict(makeVerdict('action', { detail: `已记录升级前基线（${profDir}）` }));
         console.log(`  核心版本: ${base.coreVersion ?? '(未能确定)'} | bundle ${base.bundleCount} 个 | entry ${Object.keys(base.entries).length} 条`);
         console.log('  下一步：升级 dsh，然后运行');
         console.log(`    npx @moonquake2004/dsh-doctor --post-upgrade --profile ${profileArg || 'web'}`);
@@ -2897,7 +2986,7 @@ async function run() {
     }
     const base = readPreUpgrade(profDir);
     if (!base) {
-      console.error(`✗ 没找到升级前基线（${join(profDir, PRE_UPGRADE_FILE)}）——请先在升级前运行 --pre-upgrade`);
+      printVerdict(makeVerdict('fail', { detail: `没找到升级前基线（${join(profDir, PRE_UPGRADE_FILE)}）——请先在升级前运行 --pre-upgrade` }), { stream: 'stderr' }); // 错误路径：非判定
       process.exit(1);
     }
     const nowCore = coreVersion();
@@ -2920,12 +3009,12 @@ async function run() {
     for (const l of lines) console.log(`  · ${l}`);
     const verdictPost = bootVerdict(results);
     if (verdictPost.state === 'skip') {
-      console.log(`  ⊖ ${verdictPost.reason}——**不改写已知良好基线**`);
+      printVerdict(makeVerdict('skip', { reason: `${verdictPost.reason}——不改写已知良好基线` }), { indent: true });
     } else if (verdictPost.state === 'pass') {
-      console.log('  ✓ 装载模拟通过——升级未破坏任何可探测 entry');
+      printVerdict(makeVerdict('pass', { checked: verdictPost.checked, detail: '装载模拟通过——升级未破坏任何可探测 entry' }), { indent: true });
       writeSnapshot(profDir, nowSnap);
     } else {
-      console.log(`  ✗ 装载模拟失败 ${failed.length} 条（这就是"升级后起不来"的直接原因）：`);
+      printVerdict(makeVerdict('fail', { detail: `装载模拟失败 ${failed.length} 条（这就是"升级后起不来"的直接原因）：` }), { indent: true });
       for (const f of failed) {
         console.log(`      [${f.bundle}] ${f.id} → ${f.spec}`);
         console.log(`        ${f.kind}: ${f.error}`);
@@ -2948,15 +3037,15 @@ async function run() {
     const profDir = resolveProfile(profileArg || 'web');
     const r = safeAdd(profileArg || 'web', safeAddArg);
     if (jsonOut) console.log(JSON.stringify(r, null, 2));
-    else if (r.ok && r.stage === 'verified') console.log(`✓ 已安装并预检通过（${r.checked} 条 entry 均可导入）——重启 dsh 即可`);
+    else if (r.ok && r.stage === 'verified') printVerdict(makeVerdict('pass', { checked: r.checked, detail: `已安装并预检通过（${r.checked} 条 entry 均可导入）——重启 dsh 即可` }));
     else if (r.ok && r.stage === 'quarantined') {
       console.log(`⚠ 已安装，但该插件的 entry 导入失败，已自动隔离以避免 dsh 起不来：`);
       for (const f of r.failures || []) console.log(`    ${f}`);
       console.log(`  隔离项：${r.quarantined.join(', ')}（用 --unquarantine <包名> 放回，修好版本后再重试）`);
       console.log(`  dsh 现在可以正常启动。`);
-    } else if (r.stage === 'install') console.log(`✗ 安装命令本身失败（exit ${r.exit}），已还原 manifest`);
+    } else if (r.stage === 'install') printVerdict(makeVerdict('fail', { detail: `安装命令本身失败（exit ${r.exit}），已还原 manifest` }));
     else {
-      console.log(`✗ 安装后无法启动，且隔离也救不回来 → 已整体回滚到安装前状态`);
+      printVerdict(makeVerdict('fail', { detail: '安装后无法启动，且隔离也救不回来 → 已整体回滚到安装前状态' }));
       for (const f of r.failures || []) console.log(`    ${f}`);
     }
     process.exit(r.ok ? 0 : 2);
@@ -2966,13 +3055,13 @@ async function run() {
     try {
       if (quarantineArg || unquarantineArg) {
         const r = quarantineBundle(profDir, quarantineArg || unquarantineArg, !!unquarantineArg);
-        if (!r.ok) { console.error(`✗ ${r.error}`); process.exit(1); }
+        if (!r.ok) { printVerdict(makeVerdict('fail', { detail: r.error })); process.exit(1); }
         const payload = { ok: true, action: unquarantineArg ? 'unquarantine' : 'quarantine', ...r, next: '重启 dsh；随后用 --boot-check 复查，或用 --unquarantine 撤销' };
         if (jsonOut) console.log(JSON.stringify(payload, null, 2));
         else if (unquarantineArg) {
-          console.log(`✓ 已放回 ${unquarantineArg}（当前启动列表 ${r.bundles} 项）——重启 dsh 生效`);
+          printVerdict(makeVerdict('action', { detail: `已放回 ${unquarantineArg}（当前启动列表 ${r.bundles} 项）——重启 dsh 生效` }));
         } else {
-          console.log(`✓ 已隔离 ${quarantineArg}（启动列表现为 ${r.bundles} 项；原始 package.json 已备份）`);
+          printVerdict(makeVerdict('action', { detail: `已隔离 ${quarantineArg}（启动列表现为 ${r.bundles} 项；原始 package.json 已备份）` }));
           console.log(`  重启 dsh，然后用 --boot-check 复查；要放回：--unquarantine ${quarantineArg}`);
         }
         process.exit(0);
@@ -3005,7 +3094,7 @@ async function run() {
         if (jsonOut) {
           console.log(JSON.stringify({ ok: true, skip: true, reason: '启动列表为空：没有任何 entry 可探测，未做装载模拟', profile: profDir, checked: 0, failed: 0, drift, results }, null, 2));
         } else {
-          console.log(`装载模拟（${profDir}）：⊖ 无可检查对象——启动列表为空，**未做任何装载模拟**（这不等于"通过"）`);
+          console.log(`装载模拟（${profDir}）：`); printVerdict(makeVerdict('skip', { reason: '无可检查对象——启动列表为空，未做任何装载模拟' }));
           console.log('  若你预期这里有插件：检查 profile 的 dsh.profile.bundles 是否为空，或插件是否装到了别的 profile。');
         }
         process.exit(0);
@@ -3016,10 +3105,10 @@ async function run() {
       } else {
         console.log(`装载模拟（${profDir}）：检查 ${results.length} 条 entry，失败 ${failed.length} 条`);
         for (const r of results) {
-          if (r.status === 'failed') console.log(`  ✗ [${r.bundle}] ${r.id} → ${r.spec}\n      ${r.kind}: ${r.error}\n      修复方向：${r.hint}\n      先起来：npx @moonquake2004/dsh-doctor --quarantine ${r.bundle}`);
-          else if (r.status === 'skipped') console.log(`  ⊖ ${r.id}（${r.reason}）`);
+          if (r.status === 'failed') printItem('fail', `[${r.bundle}] ${r.id} → ${r.spec}\n      ${r.kind}: ${r.error}\n      修复方向：${r.hint}\n      先起来：npx @moonquake2004/dsh-doctor --quarantine ${r.bundle}`);
+          else if (r.status === 'skipped') printItem('skip', `${r.id}（${r.reason}）`);
         }
-        if (!failed.length) console.log('  ✓ 所有可探测 entry 均可导入——启动失败若仍发生，问题多在配置合并或原生环境，请贴 --json 输出');
+        if (!failed.length) printVerdict(makeVerdict('pass', { checked: results.length, detail: '所有可探测 entry 均可导入——启动失败若仍发生，问题多在配置合并或原生环境，请贴 --json 输出' }), { indent: true });
       }
       process.exit(failed.length ? 2 : 0);
     } catch (e) {
@@ -3228,7 +3317,15 @@ async function run() {
     // 于是把 warn 当成误报。状态本就不该由消费者自行推导。
     const statusOf = (r) => (r.skip ? 'skip' : (!r.ok ? (((r.section === 'security') ? r.severity !== 'critical' : catalogSeverity.get(r.id) === 'warn') ? 'warn' : 'fail') : 'pass'));
     const checksWithStatus = results.map((r) => ({ ...r, status: statusOf(r) }));
-    console.log(JSON.stringify({ ok: bad.length === 0 && secExit === 0, checks: checksWithStatus, catalog: catalogMeta, update: updateInfo, ...(securityMeta.enabled ? { security: securityMeta } : {}) }, null, 2));
+    const aggJson = aggregateVerdict(results);
+    console.log(JSON.stringify({
+      // ok 只有在"确实验证过且无失败"时才为 true —— 修前它只看 bad.length，于是"全部跳过"也会 ok:true
+      ok: aggJson.state === 'pass',
+      verified: aggJson.totals.verified,
+      skipped: aggJson.totals.skipped,
+      failed: aggJson.totals.failed,
+      checks: checksWithStatus, catalog: catalogMeta, update: updateInfo, ...(securityMeta.enabled ? { security: securityMeta } : {}),
+    }, null, 2));
   } else {
     const sectionOrder = { env: 0, profile: 1, session: 2, catalog: 3 };
     const ordered = [...results].sort((a, b) => (sectionOrder[a.section] ?? 9) - (sectionOrder[b.section] ?? 9));
@@ -3237,18 +3334,27 @@ async function run() {
       if (r.section !== lastSection) { console.log(`\n== ${r.section === 'security' ? '🔒 安全' : r.section.toUpperCase()} ==`); lastSection = r.section; }
       const sev = catalogSeverity.get(r.id);
       // 安全检查：skip 显示 ⊖；critical/high 失败 ✗；medium 及以下失败 ⚠（不影响退出码）
-      const mark = r.skip ? '⊖'
-        : (!r.ok ? (((r.section === 'security' && r.severity !== 'critical' && r.severity !== 'high') || sev === 'warn') ? '⚠' : '✗')
-        : '✓');
-      console.log(` ${mark} [${r.id}]${r.severity ? `（${r.severity}${r.skip ? '/skip' : ''}）` : ''} ${r.detail}${r.src === 'catalog' ? '  [目录]' : ''}`);
+      // 状态名（不是符号）：符号只由 printItem/printVerdict 决定，闭集测试据此断言
+      const mark = r.skip ? 'skip'
+        : (!r.ok ? (((r.section === 'security' && r.severity !== 'critical' && r.severity !== 'high') || sev === 'warn') ? 'warn' : 'fail')
+        : 'pass');
+      printItem(mark, `[${r.id}]${r.severity ? `（${r.severity}${r.skip ? '/skip' : ''}）` : ''} ${r.detail}${r.src === 'catalog' ? '  [目录]' : ''}`, 1);
       if (!r.ok && r.fix) console.log(`     ↳ 修复: ${r.fix}`);
     }
     if (updateInfo.available && !updateInfo.applied) {
       console.log(`\n⚠ 新版本 ${updateInfo.latest} 可用（当前 ${updateInfo.current}）→ 运行 \`dsh-doctor --update\` 或 \`dsh plugin update\``);
     } else if (updateInfo.applied) {
-      console.log(`\n✓ ${updateInfo.applied}`);
+      console.log(''); printVerdict(makeVerdict('action', { detail: updateInfo.applied }));
+    }
+    const agg = aggregateVerdict(results.map((r) => ({ ...r, examined: r.examined })));
+    if (agg.state === 'fail') {
+      console.log('');
+      printVerdict(makeVerdict('fail', { detail: `${bad.length} 个内置问题${secExit > 0 ? ` + 安全 ${secExit === 2 ? 'CRITICAL' : 'HIGH'} 级失败` : ''}（profile=${profileArg}，目录=${catalogMeta.source}，${catalogMeta.checks} 条）` }));
+    } else {
+      console.log('');
+      printVerdict(agg);
+      console.log(`（profile=${profileArg}，目录=${catalogMeta.source}，${catalogMeta.checks} 条）`);
     }
-    console.log(`\n${(bad.length === 0 && secExit === 0) ? '✓ 全部通过' : `✗ ${bad.length} 个内置问题${secExit > 0 ? ` + 安全 ${secExit === 2 ? 'CRITICAL' : 'HIGH'} 级失败` : ''}`}（profile=${profileArg}，目录=${catalogMeta.source}，${catalogMeta.checks} 条）`);
   }
   // 最终退出码：内置失败 → 1；安全 HIGH → 1、CRITICAL → 2（取 max）
   process.exit(Math.max(bad.length > 0 ? 1 : 0, secExit));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moonquake2004/dsh-doctor",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "description": "Offline diagnostic for DeepSeek Harness — 28 built-in + 5 catalog checks across env/profile/session (Layer A checks-as-data), self-update (Layer B), and a semi-automatic LLM observer (Layer C, --observe); Doctor panel in web UI settings.",
   "main": "lib/index.js",
   "files": [