@dommaker/harness 1.4.0 → 1.6.0

package/src/cli/commands/__tests__/passes-gate.test.ts

@@ -130,9 +130,13 @@ describe('passes-gate command', () => {
       }));
 
       await runPassesGate({ testCommand: 'pytest' }, io);
-      expect(MockPassesGate).toHaveBeenCalledWith(
-        expect.objectContaining({ testCommand: 'pytest' })
-      );
+      // 精确形状（A1）：装配面只剩四个活字段，只写不读的重试字段已随旗帜一并删除
+      expect(MockPassesGate).toHaveBeenCalledWith({
+        enabled: true,
+        testCommand: 'pytest',
+        requireEvidence: false,
+        allowPartialPass: false,
+      });
     });
   });
 

package/src/cli/commands/__tests__/performance.test.ts

@@ -35,7 +35,7 @@ describe('performance command', () => {
       passed: true,
       message: 'ok',
       details: {
-        metrics: { coverage: 85.5, bundleSize: 204800, benchmarkTime: 150 },
+        metrics: { coverage: 85.5, bundleSize: 204800 },
       },
     });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
@@ -76,7 +76,7 @@ describe('performance command', () => {
     });
   });
 
-  it('should convert bundleThreshold from KB to bytes', async () => {
+  it('bundleThreshold 直传 KB 到 maxBundleSize（不再按字节错位换算）', async () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
@@ -84,23 +84,12 @@ describe('performance command', () => {
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({
-        thresholds: expect.objectContaining({ bundleSize: 500 * 1024 }),
+        thresholds: expect.objectContaining({ maxBundleSize: 500 }),
       }),
     );
   });
 
-  it('should convert benchmarkTimeout from seconds to ms', async () => {
-    const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
-
-    await performance({ benchmarkTimeout: 30 }, io);
-
-    expect(MockGate).toHaveBeenCalledWith(
-      expect.objectContaining({ benchmarkTimeout: 30000 }),
-    );
-  });
-
-  it('should set coverage threshold when both flags provided', async () => {
+  it('coverage 旗帜对齐 minCoverage 字段（原 coverage 错位键名恒不生效）', async () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
@@ -108,7 +97,7 @@ describe('performance command', () => {
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({
-        thresholds: expect.objectContaining({ coverage: 90 }),
+        thresholds: expect.objectContaining({ minCoverage: 90 }),
       }),
     );
   });

package/src/cli/commands/__tests__/project-path-convention.test.ts

@@ -7,9 +7,11 @@
  *
  * 本文件是这条约定的机器可检面，三道闸：
  * 1. CLI 入口层：cwd 只能以 `xxx || process.cwd()` 的兜底形状出现，例外逐个点名并记理由
- * 2. 下游层（core / gates / context / monitoring / hooks）：cwd 站点集合冻结，
- *    新增即失败——要么把根传下去，要么在此记下豁免理由
- * 3. `xxxPath: '相对路径'` 默认值同理冻结（acceptance 的 `tasksPath: './tasks.yml'` 就是这一类）
+ * 2. 下游层（= src 减 cli，含 core / gates / context / monitoring / hooks 等）：cwd 站点**逐行**冻结
+ *    （harness#98，不再只冻文件键集——豁免文件内新增站点/行变形同样失败），
+ *    要么把根传下去，要么在此记下豁免理由
+ * 3. 相对路径默认值同理冻结（harness#98 收紧：对象字面量 `xxxPath: '相对'` 之外，
+ *    参数默认值形 `xxxPath = '相对'`（含类型标注）与模板字面量同罪；扫描域 = 整个下游层）
  *
  * 冻结集合还要求**每条豁免仍然成立**（站点消失却不删条目 → 同样失败），豁免不会烂成化石。
  * 「根参数已传入却又取 cwd」这类静态看不出的漂移，由 project-path-anchoring.test.ts 的真实 IO 行为用例守。
@@ -83,28 +85,86 @@ const CLI_CWD_EXEMPTIONS: Record<string, { lines: string[]; reason: string }> =
  * 下游豁免的共同理由：这些是**库层公开 API 的可选根参数默认值**（调用方没给根时的缺省），
  * 不是「根已经传进来了，取 IO 时又绕回 cwd」。core 不能 import cli，兜底只能留在各自入口，
  * 故冻结而非删除；新增站点必须在此逐个点名并单独说明。
+ *
+ * harness#98：冻结粒度从文件键集收紧到**行内容**——已豁免文件内悄悄新增 cwd 站点
+ * （不动键集）曾是绕过通道，现在新增行/行变形都会顶失败。
  */
-const DOWNSTREAM_CWD_EXEMPTIONS: Record<string, string> = {
-  'src/context/session-manager.ts': '构造参数 basePath 缺省（会话存储根，CLI 已显式传 projectPath）',
-  'src/core/constraints/checker.ts': 'check 上下文缺 projectPath 时的根兜底（3 处同一形状）',
-  'src/core/constraints/checkers/types.ts': 'checker 环境的根兜底（context.projectPath 可选）',
-  'src/core/constraints/context-builder.ts': 'buildCheckEnv 的 options.projectPath 缺省兜底（2 处）',
-  'src/core/constraints/usage-report.ts': 'projectRoot 形参默认值（库层可选根）',
-  'src/core/effective-constraints.ts': '生效集三函数 projectRoot 形参默认值（库层可选根，JSDoc 已声明）',
-  'src/core/project-config-loader.ts': 'config 加载器 projectPath 构造参数缺省兜底',
-  'src/core/spec/validator.ts': 'validateAll 的可选 projectPath 兜底（其相对 schemaPath 默认值见闸 3 豁免）',
-  'src/gates/checker-gate.ts': 'GateContext.projectPath 缺省兜底（门禁适配器的根入口）',
-  'src/gates/effective-gates.ts': 'projectRoot 形参默认值（库层可选根）',
-  'src/hooks/bootstrap.ts': 'bootstrapHarness 的可选 projectPath 兜底（组合根入口，2 处）',
-  'src/monitoring/context-tracker.ts': 'basePath 构造参数缺省兜底',
+const DOWNSTREAM_CWD_EXEMPTIONS: Record<string, { lines: string[]; reason: string }> = {
+  'src/context/session-manager.ts': {
+    lines: ['this.basePath = basePath || process.cwd();'],
+    reason: '构造参数 basePath 缺省（会话存储根，CLI 已显式传 projectPath）',
+  },
+  'src/core/constraints/checker.ts': {
+    lines: [
+      'const projectPath = context.projectPath || process.cwd();',
+      'const run = evidence ?? createGitEvidence(context.projectPath || process.cwd());',
+      'const run = evidence ?? createGitEvidence(context.projectPath || process.cwd());',
+    ],
+    reason: 'check 上下文缺 projectPath 时的根兜底（3 处同一形状）',
+  },
+  'src/core/constraints/checkers/types.ts': {
+    lines: ['const projectPath = context.projectPath || process.cwd();'],
+    reason: 'checker 环境的根兜底（context.projectPath 可选）',
+  },
+  'src/core/constraints/context-builder.ts': {
+    lines: [
+      'const projectPath = options.projectPath || process.cwd();',
+      'const projectPath = options.projectPath || process.cwd();',
+    ],
+    reason: 'buildCheckEnv 的 options.projectPath 缺省兜底（2 处）',
+  },
+  'src/core/constraints/usage-report.ts': {
+    lines: ['projectRoot: string = process.cwd(),'],
+    reason: 'projectRoot 形参默认值（库层可选根）',
+  },
+  'src/core/effective-constraints.ts': {
+    lines: [
+      'projectRoot: string = process.cwd(),',
+      'projectRoot: string = process.cwd(),',
+      'export function lintEffectiveConfig(projectRoot: string = process.cwd()): EffectiveConfigLint {',
+    ],
+    reason: '生效集三函数 projectRoot 形参默认值（库层可选根，JSDoc 已声明）',
+  },
+  'src/core/project-config-loader.ts': {
+    lines: ['this.projectPath = projectPath || process.cwd();'],
+    reason: 'config 加载器 projectPath 构造参数缺省兜底',
+  },
+  'src/core/spec/validator.ts': {
+    lines: ['const cwd = projectPath || process.cwd();'],
+    reason: 'validateAll 的可选 projectPath 兜底（其相对 schemaPath 默认值见闸 3 豁免）',
+  },
+  'src/gates/checker-gate.ts': {
+    lines: ['const projectPath = ctx.projectPath || process.cwd();'],
+    reason: 'GateContext.projectPath 缺省兜底（门禁适配器的根入口）',
+  },
+  'src/gates/effective-gates.ts': {
+    lines: ['export function getEffectiveGates(projectRoot: string = process.cwd()): Gate[] {'],
+    reason: 'projectRoot 形参默认值（库层可选根）',
+  },
+  'src/hooks/bootstrap.ts': {
+    lines: [
+      'const resolvedPath = projectPath || process.cwd();',
+      'const resolvedPath = projectPath || process.cwd();',
+    ],
+    reason: 'bootstrapHarness 的可选 projectPath 兜底（组合根入口，2 处）',
+  },
+  'src/monitoring/context-tracker.ts': {
+    lines: ['const base = basePath || process.cwd();'],
+    reason: 'basePath 构造参数缺省兜底',
+  },
 };
 
 // ========================================
-// 闸 3：core/gates 的相对路径默认值
+// 闸 3：下游层的相对路径默认值
 // ========================================
 
-/** key 必须 camelCase 以 Path 结尾，值为相对字面量——这类默认值按 cwd 解析，即 #95 的病根形状 */
-const RELATIVE_PATH_DEFAULT = /\b\w+Path\s*:\s*'(?!\/)([^']+)'/;
+/**
+ * key 必须 camelCase 以 Path 结尾，值为相对字面量——这类默认值按 cwd 解析，即 #95 的病根形状。
+ * harness#98 收紧匹配形状（原为只认对象字面量 `xxxPath: '相对'`）：
+ * 参数默认值形 `xxxPath = '相对'`、带类型标注的 `xxxPath: string = '相对'`、模板字面量、
+ * 双引号形同罪（仓内 lint 不强制引号风格，三种引号都得认）。
+ */
+const RELATIVE_PATH_DEFAULT = /\b\w+Path\s*(?::\s*[^=,)]+?)?[:=]\s*['"`](?!\/)/;
 
 const RELATIVE_PATH_DEFAULT_EXEMPTIONS: Record<string, string> = {
   'src/core/spec/validator.ts':
@@ -133,11 +193,13 @@ describe('projectPath 传递约定（harness#95）', () => {
   });
 
   describe('闸 2：下游层不得二次取 cwd', () => {
-    it('下游 cwd 站点集合 = 冻结豁免表（新增即失败；站点消失却不删条目也失败）', () => {
+    it('下游 cwd 站点 = 冻结豁免表且逐行一致（新增文件/新增行/行变形/豁免化石都失败）', () => {
       const sites = cwdSites(downstreamFiles);
 
       expect([...sites.keys()].sort()).toEqual(Object.keys(DOWNSTREAM_CWD_EXEMPTIONS).sort());
-      expect(sites.size).toBe(Object.keys(DOWNSTREAM_CWD_EXEMPTIONS).length);
+      for (const [rel, exemption] of Object.entries(DOWNSTREAM_CWD_EXEMPTIONS)) {
+        expect({ rel, lines: sites.get(rel) }).toEqual({ rel, lines: exemption.lines });
+      }
     });
 
     it('PassesGate 执行侧不再取 cwd（站点 1 的收口形状：workDir 由调用方传入）', () => {
@@ -149,9 +211,9 @@ describe('projectPath 传递约定（harness#95）', () => {
   });
 
   describe('闸 3：相对路径默认值不再按 cwd 解析', () => {
-    it('core/gates 里 xxxPath: 相对字面量 的站点 = 冻结豁免表', () => {
+    it('下游层（= src 减 cli）的相对字面量路径默认值 = 冻结豁免表', () => {
       const hits = new Set<string>();
-      for (const file of listTsFiles(path.join(SRC_ROOT, 'core')).concat(listTsFiles(path.join(SRC_ROOT, 'gates')))) {
+      for (const file of downstreamFiles) {
         if (codeLines(file).some(line => RELATIVE_PATH_DEFAULT.test(line))) hits.add(repoPath(file));
       }
 

package/src/cli/commands/__tests__/registry.test.ts

@@ -4,7 +4,7 @@
  * - 定义表内每个实现引用（module+export）都必须可解析（构建/测试期断言，
  *   取代 commands barrel 的编译期保护——R6 消灭手工同步后的闭环兜底）
  * - definitions 是纯数据模块：require 它不加载任何命令实现（保 --help/--version 懒加载）
- * - 命令面与 CAPABILITIES.md 的 24 顶层命令一致（防误删回归）
+ * - 命令面与 CAPABILITIES.md 的 21 顶层命令一致（防误删回归）
  * - bin/harness.js 端到端冒烟（dist 存在时）：--version/--help 零命令实现模块，
  *   单命令执行只加载该命令模块（O2 per-command 懒加载）
  */
@@ -35,7 +35,7 @@ function collectRefs(defs: CommandDefinition[]): CommandImplRef[] {
 const EXPECTED_TOP_LEVEL_COMMANDS = [
   'check', 'validate', 'passes-gate', 'init', 'report', 'status', 'spec',
   'sync-docs', 'knowledge', 'sdd', 'failure', 'posteval-plan',
-  'update-user-model', 'release', 'analyze-sessions', 'constraints',
+  'release', 'constraints',
   'spec-baseline-check',
   // 6 门禁命令（GATE_DEFINITIONS 驱动）
   'acceptance', 'command', 'contract', 'performance', 'review', 'security',
@@ -88,7 +88,7 @@ describe('命令注册表闭环', () => {
     }
   });
 
-  it('顶层命令面与预期 24 命令一致（含 6 门禁）', () => {
+  it('顶层命令面与预期 21 命令一致（含 6 门禁）', () => {
     const names = [
       ...COMMAND_DEFINITIONS.map(d => d.command.split(' ')[0]),
       ...GATE_DEFINITIONS.map(d => d.cli.command.split(' ')[0]),
@@ -97,6 +97,49 @@ describe('命令注册表闭环', () => {
     expect(names.sort()).toEqual([...EXPECTED_TOP_LEVEL_COMMANDS].sort());
   });
 
+  /**
+   * 文档手抄面根因闸（review A5）
+   *
+   * `CLAUDE.md` 的「N CLI subcommands (…)」与 `cli/commands/CONTEXT.md` 的命令清单/计数
+   * 都是注册表实面的人工抄本，无闸时必然漂移：#122 机械 −2 后 CLAUDE.md 仍列着早已按
+   * ADR-0009 删除的 `doc-freshness-check`，声明 22 而实面 21。三向钉死——计数等于条数、
+   * 无幽灵条目、无漏列条目。
+   */
+  it('CLAUDE.md 与 cli/commands/CONTEXT.md 的命令抄本与定义表实面双向一致', () => {
+    const actual = [
+      ...COMMAND_DEFINITIONS.map(d => d.command.split(' ')[0]),
+      ...GATE_DEFINITIONS.map(d => d.cli.command.split(' ')[0]),
+    ].sort();
+
+    const claudeLine = fs
+      .readFileSync(path.join(repoRoot, 'CLAUDE.md'), 'utf-8')
+      .split('\n')
+      .find(line => line.includes('| `src/cli/commands/` |'));
+    expect(claudeLine).toBeDefined();
+    const claudeMatch = (claudeLine || '').match(/(\d+) CLI subcommands \(([^)]*)\)/);
+    expect(claudeMatch).toBeDefined();
+    const claudeNames = claudeMatch![2]
+      .split(',')
+      .map(name => name.trim())
+      .filter(Boolean)
+      .sort();
+    expect(Number(claudeMatch![1])).toBe(actual.length);
+    expect(claudeNames).toEqual(actual);
+
+    const contextDoc = fs.readFileSync(path.join(repoCommandsDir, 'CONTEXT.md'), 'utf-8');
+    const contextCount = contextDoc.match(/(\d+) 个顶层命令/);
+    expect(contextCount).toBeDefined();
+    expect(Number(contextCount![1])).toBe(actual.length);
+    const contextNames = [
+      ...(contextDoc.match(/各命令文件：([^\n]+)/)?.[1] || '').split('/'),
+      ...(contextDoc.match(/门禁命令实现在 ([^（]+)（/)?.[1] || '').split('/'),
+    ]
+      .map(name => name.replace(/`/g, '').trim())
+      .filter(Boolean)
+      .sort();
+    expect(contextNames).toEqual(actual);
+  });
+
   it('命令定义无重复注册名', () => {
     const names = COMMAND_DEFINITIONS.map(d => d.command);
     expect(new Set(names).size).toBe(names.length);
@@ -175,6 +218,12 @@ function runWithModuleProbe(argv: string[]): { status: number | null; implModule
   }
 }
 
+// CI 上 dist 缺失时显式失败而非静默 skip（harness#99）：bin 懒加载/路由的
+// 端到端证据在下面的 smoke 块，CI 必须先 build 再 test，否则证据隐形。
+if (!hasDist && process.env.CI) {
+  throw new Error('dist 未构建：bin 端到端 smoke 不得静默 skip —— CI 必须先 npm run build 再 npm test（harness#99）');
+}
+
 const smoke = hasDist ? describe : describe.skip;
 
 smoke('bin/harness.js 端到端（dist 存在时）', () => {

package/src/cli/commands/__tests__/report-extra.test.ts

@@ -52,18 +52,6 @@ describe('report command - 补充覆盖', () => {
     });
   });
 
-  describe('HTML 报告完整内容', () => {
-    it('HTML 报告应该包含所有区块', async () => {
-      await report({ format: 'html' }, io);
-      const output = io.outText();
-
-      expect(output).toContain('<!DOCTYPE html>');
-      expect(output).toContain('<title>Harness 检查报告</title>');
-      expect(output).toContain('约束检查');
-      expect(output).toContain('Iron Laws');
-    });
-  });
-
   describe('文件输出', () => {
     it('Markdown 输出到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
@@ -71,13 +59,6 @@ describe('report command - 补充覆盖', () => {
       await report({ format: 'markdown', output: 'report.md' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.md', expect.stringContaining('# Harness'), 'utf-8');
     });
-
-    it('HTML 输出到文件', async () => {
-      mockFs.writeFile.mockResolvedValue(undefined);
-
-      await report({ format: 'html', output: 'report.html' }, io);
-      expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
-    });
   });
 
   describe('JSON 报告内容', () => {

package/src/cli/commands/__tests__/report-false-green.test.ts

@@ -0,0 +1,46 @@
+/**
+ * report 假绿回归（架构评审候选1）
+ *
+ * 历史 bug：report 经 executeWithCollect 调 checkConstraints，checker 在首个
+ * 铁律违规即 throw，handler 的 catch 丢弃 error.result 并合成空结果 ——
+ * 铁律违规被报成 violations: [] / passed = 全量（假绿）。
+ * 修复后 report 直调 checker.collectConstraints（不抛、全量收集），违规如实上报。
+ *
+ * fixture：CAPABILITIES.md 登记幽灵文件 → docs_freshness（file_modification
+ * 触发域内唯一铁律）必违规。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { report } from '../report';
+import { captureIO } from '../../command-contract';
+import { createProjectFixture } from '../../../test-setup/project-fixture';
+
+// 与 three-state-consistency.test.ts 相同的表格正本形状
+const GHOST_CAPABILITIES =
+  '# Capabilities\n\n' +
+  '| 模块 | 文件 | 说明 |\n' +
+  '|------|------|------|\n' +
+  '| 遗魂 | src/gone.ts | 已删 |\n';
+
+function parseJsonReport(output: string) {
+  const start = output.indexOf('{');
+  const end = output.lastIndexOf('}');
+  return JSON.parse(output.slice(start, end + 1));
+}
+
+describe('report 铁律违规如实上报（假绿回归）', () => {
+  it('docs_freshness 违规 → failed ≥ 1、violations 点名、passed < total', async () => {
+    const root = createProjectFixture({
+      name: 'report-false-green',
+      files: { 'CAPABILITIES.md': GHOST_CAPABILITIES },
+    });
+    const io = captureIO();
+
+    await report({ format: 'json', projectPath: root }, io);
+
+    const data = parseJsonReport(io.outText());
+    expect(data.constraints.failed).toBeGreaterThanOrEqual(1);
+    expect(data.constraints.violations.map((v: { id: string }) => v.id)).toContain('docs_freshness');
+    expect(data.constraints.passed).toBeLessThan(data.constraints.total);
+  });
+});

package/src/cli/commands/__tests__/report.test.ts

@@ -44,11 +44,6 @@ describe('report command', () => {
       expect(io.outText()).toContain('Harness 检查报告');
     });
 
-    it('应该生成 HTML 格式报告', async () => {
-      await report({ format: 'html' }, io);
-      expect(io.outText()).toContain('<!DOCTYPE html>');
-    });
-
     it('应该保存报告到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
 
@@ -70,15 +65,6 @@ describe('report command', () => {
       expect(output).toContain('报告由 @dommaker/harness 生成');
     });
 
-    it('HTML 报告应包含完整结构', async () => {
-      await report({ format: 'html' }, io);
-      const output = io.outText();
-      expect(output).toContain('<html lang="zh-CN">');
-      expect(output).toContain('</html>');
-      expect(output).toContain('Harness 检查报告');
-      expect(output).toContain('<table>');
-    });
-
     it('JSON 报告应包含约束统计', async () => {
       await report({ format: 'json' }, io);
       const output = io.outText();
@@ -99,11 +85,5 @@ describe('report command', () => {
       await report({ format: 'markdown', output: 'report.md' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.md', expect.stringContaining('# Harness'), 'utf-8');
     });
-
-    it('应该支持输出到文件 (html)', async () => {
-      mockFs.writeFile.mockResolvedValue(undefined);
-      await report({ format: 'html', output: 'report.html' }, io);
-      expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
-    });
   });
 });

package/src/cli/commands/__tests__/status-analysis-wiring.test.ts

@@ -0,0 +1,68 @@
+/**
+ * status 的分析接线（ADR-0020）
+ *
+ * `status` 要的是「对已读出的 traces 做纯判定」，此前却为此构造
+ * `new TraceCollector({traceFile})`（构造函数带 mkdir 副作用）+ `new TraceAnalyzer(c)`，
+ * 测试端再叠一层 TraceAnalyzer mock 才能断言。ADR-0020 把判定下放为模块级纯函数后，
+ * 本命令直调函数，构造仪式退出这条路径。
+ *
+ * 用真实临时工程根跑一遍（不 mock fs），顺带钉住「换成直调后统计与异常输出口径不变」。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { createProjectFixture } from '../../../test-setup/project-fixture';
+import { captureIO, type CapturingIO } from '../../command-contract';
+import { status } from '../status';
+
+const STATUS_SOURCE = fs.readFileSync(path.join(__dirname, '..', 'status.ts'), 'utf-8');
+
+/** 1 pass + 1 fail：failRate 0.5、passRate 0.5 → 无异常；2 fail：passRate 0 → low_pass_rate */
+const PASS = { constraintId: 'alpha', level: 'iron_law' as const, result: 'pass' as const };
+const FAIL = { constraintId: 'beta', level: 'guideline' as const, result: 'fail' as const };
+
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
+describe('status 分析接线（ADR-0020）', () => {
+  it('不再构造 TraceCollector / TraceAnalyzer', () => {
+    expect(STATUS_SOURCE).not.toMatch(/new\s+TraceCollector\s*\(/);
+    expect(STATUS_SOURCE).not.toMatch(/new\s+TraceAnalyzer\s*\(/);
+    expect(STATUS_SOURCE).not.toMatch(/from\s+'[^']*monitoring\/traces'/);
+  });
+
+  it('直调 trace-analyzer 的模块级纯函数取统计与异常', () => {
+    expect(STATUS_SOURCE).toMatch(/summarizeTraces\s*\(/);
+    expect(STATUS_SOURCE).toMatch(/detectTraceAnomalies\s*\(/);
+  });
+
+  it('真实工程根跑通：按纯函数口径出统计，全过数据零异常', async () => {
+    const root = createProjectFixture({
+      name: 'status-pure-analysis',
+      config: 'project:\n  name: status-pure-analysis\n',
+      traces: [PASS, { ...PASS, timestamp: 2 }],
+    });
+
+    await status({ projectPath: root, detail: true }, io);
+
+    expect(io.outText()).toContain('🔴 Iron Laws:');
+    expect(io.outText()).toContain('alpha');
+    expect(io.outText()).toContain('检查: 2 | 通过: 100% | 失败: 0%');
+    expect(io.outText()).not.toContain('个异常');
+    expect(io.outText()).toContain('继续积累数据');
+  });
+
+  it('真实工程根跑通：低通过率经纯函数判为异常并列出', async () => {
+    const root = createProjectFixture({
+      name: 'status-pure-analysis',
+      traces: [FAIL, { ...FAIL, timestamp: 2 }],
+    });
+
+    await status({ projectPath: root, anomalies: true }, io);
+
+    expect(io.outText()).toContain('发现 1 个异常');
+    expect(io.outText()).toContain('类型: low_pass_rate');
+  });
+});