@dommaker/harness 1.5.0 → 1.7.0

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__/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);

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');
+  });
+});

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

@@ -1,11 +1,14 @@
 /**
  * status 命令补充测试
+ *
+ * ADR-0020 起不再 mock TraceAnalyzer/TraceCollector：异常判定走真实纯函数，
+ * 用例喂能真的判出异常的 trace（passRate < 0.3 → low_pass_rate）。
  */
 
 import { status } from '../status';
 import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs';
-import { TraceAnalyzer } from '../../../monitoring/trace-analyzer';
+import type { ExecutionTrace } from '../../../types/trace';
 
 // Mock fs
 jest.mock('fs', () => ({
@@ -15,22 +18,6 @@ jest.mock('fs', () => ({
   writeFileSync: jest.fn(),
 }));
 
-// Mock TraceCollector
-jest.mock('../../../monitoring/traces', () => ({
-  TraceCollector: jest.fn().mockImplementation(() => ({
-    record: jest.fn(),
-    read: jest.fn().mockReturnValue([]),
-  })),
-}));
-
-// Mock TraceAnalyzer
-jest.mock('../../../monitoring/trace-analyzer', () => ({
-  TraceAnalyzer: jest.fn().mockImplementation(() => ({
-    summarize: jest.fn().mockReturnValue([]),
-    detectAnomalies: jest.fn().mockReturnValue([]),
-  })),
-}));
-
 // Mock chalk
 jest.mock('chalk', () => ({
   blue: jest.fn((str: string) => str),
@@ -41,7 +28,18 @@ jest.mock('chalk', () => ({
 }));
 
 const mockFs = fs as jest.Mocked<typeof fs>;
-const MockTraceAnalyzer = TraceAnalyzer as jest.MockedClass<typeof TraceAnalyzer>;
+
+/** trace 文件内容：一 trace 一行，缺省字段补齐成合法 ExecutionTrace（timestamp 递增） */
+function traceFile(traces: Array<Partial<ExecutionTrace>>): string {
+  return traces
+    .map((t, i) => JSON.stringify({ level: 'iron_law', timestamp: i + 1, result: 'pass', ...t }))
+    .join('\n');
+}
+
+/** n 条同一约束的 pass/fail 记录 */
+function repeats(constraintId: string, n: number, result: ExecutionTrace['result']): Array<Partial<ExecutionTrace>> {
+  return Array.from({ length: n }, () => ({ constraintId, result }));
+}
 
 let io: CapturingIO;
 beforeEach(() => {
@@ -60,140 +58,89 @@ describe('status command - 补充覆盖', () => {
 
   describe('异常检测完整流程', () => {
     it('有异常时应该显示详细信息和下一步建议', async () => {
-      const mockTraces = [
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', result: 'fail' },
-      ];
-      mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
-
-      const mockAnomalies = [
-        {
-          constraintId: 'no_bypass_checkpoint',
-          type: 'high_failure_rate',
-          current: 0.8,
-          threshold: 0.5,
-        },
-        {
-          constraintId: 'no_completion_without_verification',
-          type: 'frequent_bypass',
-          current: 0.3,
-          threshold: 0.1,
-        },
-      ];
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue([
-          { constraintId: 'no_bypass_checkpoint', level: 'iron_law', passRate: 0.2, failRate: 0.8, totalChecks: 10 },
-        ]),
-        detectAnomalies: jest.fn().mockReturnValue(mockAnomalies),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      // 两个约束各自全失败 → 各自判出一枚 low_pass_rate
+      mockFs.readFileSync.mockReturnValue(traceFile([
+        ...repeats('no_bypass_checkpoint', 2, 'fail'),
+        ...repeats('no_completion_without_verification', 2, 'fail'),
+      ]));
 
       await status({ anomalies: true }, io);
-      
+
       const output = io.outText();
-      expect(output).toContain('异常');
-      expect(mockAnalyze.detectAnomalies).toHaveBeenCalled();
+      expect(output).toContain('发现 2 个异常');
+      expect(output).toContain('no_completion_without_verification');
+      expect(output).toContain('类型: low_pass_rate');
+      expect(output).toContain('下一步建议');
     });
 
     it('无异常时应该显示未发现异常', async () => {
-      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test', level: 'iron_law', result: 'pass' }));
-
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue([]),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      mockFs.readFileSync.mockReturnValue(traceFile([
+        { constraintId: 'test', result: 'pass' },
+      ]));
 
       await status({ anomalies: true }, io);
-      
-      const output = io.outText();
-      expect(output).toContain('未发现异常');
+
+      expect(io.outText()).toContain('✅ 未发现异常');
     });
   });
 
   describe('约束级别统计', () => {
     it('应该显示 Iron Laws 统计', async () => {
-      const mockTraces = [
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', result: 'pass' },
-        { constraintId: 'no_completion_without_verification', level: 'iron_law', result: 'pass' },
-      ];
-      mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
-
-      const mockSummaries = [
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', passRate: 1, failRate: 0, totalChecks: 10 },
-        { constraintId: 'no_completion_without_verification', level: 'iron_law', passRate: 0.8, failRate: 0.2, totalChecks: 5 },
-      ];
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue(mockSummaries),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      mockFs.readFileSync.mockReturnValue(traceFile([
+        { constraintId: 'no_bypass_checkpoint' },
+        { constraintId: 'no_completion_without_verification' },
+      ]));
 
       await status({}, io);
-      
+
       const output = io.outText();
-      expect(output).toContain('约束统计');
+      expect(output).toContain('📈 约束统计:');
+      expect(output).toContain('🔴 Iron Laws:');
+      expect(output).toContain('✅ no_completion_without_verification');
     });
 
     it('应该显示 Guidelines 统计', async () => {
-      const mockTraces = [
+      mockFs.readFileSync.mockReturnValue(traceFile([
         { constraintId: 'capability_sync', level: 'guideline', result: 'pass' },
-      ];
-      mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
-
-      const mockSummaries = [
-        { constraintId: 'capability_sync', level: 'guideline', passRate: 0.9, failRate: 0.1, totalChecks: 20 },
-      ];
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue(mockSummaries),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      ]));
 
       await status({}, io);
-      
-      expect(io.outText()).not.toBe('');
+
+      expect(io.outText()).toContain('🟡 Guidelines:');
     });
   });
 
   describe('详细模式扩展', () => {
     it('详细模式应该显示所有级别详情', async () => {
-      const mockTraces = [
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', result: 'pass' },
-        { constraintId: 'capability_sync', level: 'guideline', result: 'pass' },
-      ];
-      mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
-
-      const mockSummaries = [
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', passRate: 1, failRate: 0, totalChecks: 10 },
-        { constraintId: 'capability_sync', level: 'guideline', passRate: 0.9, failRate: 0.1, totalChecks: 20 },
-      ];
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue(mockSummaries),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      mockFs.readFileSync.mockReturnValue(traceFile([
+        { constraintId: 'no_bypass_checkpoint', level: 'iron_law' },
+        { constraintId: 'capability_sync', level: 'guideline' },
+        { constraintId: 'capability_sync', level: 'guideline' },
+      ]));
 
       await status({ detail: true }, io);
-      
+
       const output = io.outText();
-      expect(output).toContain('约束统计');
+      expect(output).toContain('📈 约束统计:');
+      expect(output).toContain('🔴 Iron Laws:');
+      expect(output).toContain('🟡 Guidelines:');
+      expect(output).toContain('检查: 2 | 通过: 100% | 失败: 0%');
     });
   });
 
   describe('JSON parse 异常处理', () => {
     it('无效 JSON 行应该被过滤', async () => {
-      mockFs.readFileSync.mockReturnValue('invalid json\n{"valid":"data"}\nalso invalid');
-
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue([]),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
+      mockFs.readFileSync.mockReturnValue(
+        ['invalid json', JSON.stringify({ constraintId: 'valid', level: 'iron_law', timestamp: 1, result: 'pass' }), 'also invalid'].join('\n')
+      );
 
       await status({}, io);
-      
-      // 应该成功处理，不会抛出异常
-      expect(io.outText()).not.toBe('');
+
+      // 应该成功处理，不会抛出异常：坏行进 stderr 告知，合法行进统计
+      const output = io.outText();
+      expect(output).toContain('记录数: 3 条');
+      expect(output).toContain('✅ valid');
+      expect(io.errText()).toContain('2 行损坏');
     });
   });
-});
+});