@dommaker/harness 1.2.3 → 1.4.0

package/src/core/validators/passes-gate.ts

@@ -3,9 +3,12 @@
  * 
  * 确保 task.passes 字段只能通过测试结果修改
  * 禁止 Agent 自评通过
+ *
+ * 「过了没」的判定依据不在本文件：唯一入口是 test-output.ts 的 judgeTestRun（ADR-0014）
  */
 
 import { execAsync, delay } from '../../utils/exec';
+import { judgeTestRun } from './test-output';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import type {
@@ -13,8 +16,6 @@ import type {
   PassesGateResult,
   TaskTestResult,
   DynamicTask,
-  PassesGateExtension,
-  ExtensionTestResult,
   TestResult,
   PassesGateCheckResult,
   PassesGateViolation,
@@ -47,6 +48,51 @@ const PROTECTED_TEST_PATTERNS = [
   '**/__tests__/**',
 ];
 
+/**
+ * 检测项目的测试命令（唯一正本，CLI 与库调用共消费，架构评审 A2）
+ *
+ * 探测顺序：test:ci → test（排除 npm 默认 echo 占位脚本）→ test:e2e → test:coverage
+ * → Python（pyproject.toml 或 pytest.ini 任一）→ go.mod。
+ * 探不到返回 undefined，兜底策略归调用方（CLI 映射为 skip；PassesGate 内部 fail-closed）。
+ */
+export async function detectTestCommand(projectPath: string): Promise<string | undefined> {
+  try {
+    const content = await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8');
+    const pkg = JSON.parse(content);
+
+    if (pkg.scripts?.['test:ci']) {
+      return 'npm run test:ci';
+    }
+    if (pkg.scripts?.test && pkg.scripts.test !== 'echo "Error: no test specified"') {
+      return 'npm test';
+    }
+    if (pkg.scripts?.['test:e2e']) {
+      return 'npm run test:e2e';
+    }
+    if (pkg.scripts?.['test:coverage']) {
+      return 'npm run test:coverage';
+    }
+  } catch {
+    // 没有 package.json，继续探测其他项目类型
+  }
+
+  // Python 项目：pyproject.toml 或 pytest.ini 任一命中
+  for (const marker of ['pyproject.toml', 'pytest.ini']) {
+    try {
+      await fs.access(path.join(projectPath, marker));
+      return 'pytest';
+    } catch {}
+  }
+
+  // Go 项目
+  try {
+    await fs.access(path.join(projectPath, 'go.mod'));
+    return 'go test ./...';
+  } catch {}
+
+  return undefined;
+}
+
 /**
  * PassesGate 类
  */
@@ -219,8 +265,11 @@ export class PassesGate {
 
   /**
    * 运行测试（CLI 使用）
+   *
+   * `workDir` 必传：执行位置与证据落盘根都从这里来，不在本层取 cwd
+   * （projectPath 只在 CLI 入口兜底一次，见 src/cli/commands/CONTEXT.md）
    */
-  async runTests(): Promise<{
+  async runTests(workDir: string): Promise<{
     passed: boolean;
     passedTests: number;
     failedTests: number;
@@ -230,10 +279,9 @@ export class PassesGate {
     message?: string;
   }> {
     const startTime = Date.now();
-    const workDir = process.cwd();
-    
+
     try {
-      const testCommand = this.config.testCommand || await this.detectTestCommand(workDir);
+      const testCommand = this.config.testCommand || await detectTestCommand(workDir);
       
       if (!testCommand) {
         return {
@@ -246,7 +294,7 @@ export class PassesGate {
         };
       }
 
-      const result = await this.runTest(workDir);
+      const result = await this.runTest(workDir, undefined, testCommand);
       const duration = Date.now() - startTime;
 
       // 解析测试数量
@@ -281,155 +329,49 @@ export class PassesGate {
   /**
    * 运行测试
    */
-  private async runTest(workDir: string, _task?: DynamicTask): Promise<TaskTestResult> {
-    const testCommand = await this.detectTestCommand(workDir);
+  private async runTest(workDir: string, _task?: DynamicTask, command?: string): Promise<TaskTestResult> {
+    const testCommand = command || this.config.testCommand || await detectTestCommand(workDir);
     const timestamp = new Date();
 
-    try {
-      const { stdout } = await execAsync(testCommand, {
-        cwd: workDir,
-        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-      });
-
-      const passed = true;
-      const coverage = this.extractCoverage(stdout);
-      const failures: string[] = [];
-
+    // 探测失败 fail-closed：与 runTests 的「未检测到测试命令」分支同形状
+    if (!testCommand) {
       return {
-        passed,
-        command: testCommand,
-        output: stdout,
-        failures,
-        coverage,
-        timestamp,
-        evidence: await this.generateEvidence(workDir, stdout),
-      };
-    } catch (error: any) {
-      const output = error.stdout || '';
-      const stderrOutput = error.stderr || '';
-      const combinedOutput = output + '\n' + stderrOutput;
-
-      const failures = this.extractFailures(combinedOutput);
-      const passed = this.config.allowPartialPass && failures.length === 0;
-
-      return {
-        passed,
-        command: testCommand,
-        output: combinedOutput,
-        failures,
-        coverage: this.extractCoverage(output),
+        passed: false,
+        command: '',
+        output: '未检测到测试命令',
         timestamp,
-        evidence: await this.generateEvidence(workDir, combinedOutput),
       };
     }
-  }
-
-  /**
-   * 检测测试命令
-   */
-  private async detectTestCommand(workDir: string): Promise<string> {
-    if (this.config.testCommand) {
-      return this.config.testCommand;
-    }
-
-    // 尝试读取 package.json
-    try {
-      const packageJsonPath = path.join(workDir, 'package.json');
-      const content = await fs.readFile(packageJsonPath, 'utf-8');
-      const packageJson = JSON.parse(content);
 
-      // 优先使用 e2e 测试
-      if (packageJson.scripts?.['test:e2e']) {
-        return 'npm run test:e2e';
-      }
-      if (packageJson.scripts?.['test:coverage']) {
-        return 'npm run test:coverage';
-      }
-      if (packageJson.scripts?.test) {
-        return 'npm test';
-      }
-    } catch {
-      // package.json 不存在，尝试其他检测
-    }
-
-    // 尝试 Python 项目
-    try {
-      const pyprojectPath = path.join(workDir, 'pyproject.toml');
-      await fs.access(pyprojectPath);
-      return 'pytest';
-    } catch {
-      // 不是 Python 项目
-    }
+    let exitCode = 0;
+    let output = '';
 
-    // 尝试 Go 项目
     try {
-      const goModPath = path.join(workDir, 'go.mod');
-      await fs.access(goModPath);
-      return 'go test ./...';
-    } catch {
-      // 不是 Go 项目
-    }
-
-    // 默认命令
-    return 'npm test';
-  }
-
-  /**
-   * 从输出中提取覆盖率
-   */
-  private extractCoverage(output: string): number | undefined {
-    // Jest 格式: All files | 80.5 | 70.2 | ...
-    const jestMatch = output.match(/All files[|\s]+(\d+\.?\d*)/);
-    if (jestMatch?.[1]) {
-      return parseFloat(jestMatch[1]);
-    }
-
-    // Istanbul/nyc 格式: Statements   : 80.5% ( 100/124 )
-    const istanbulMatch = output.match(/Statements\s*:\s*(\d+\.?\d*)%/);
-    if (istanbulMatch?.[1]) {
-      return parseFloat(istanbulMatch[1]);
-    }
-
-    // pytest-cov 格式: TOTAL  1234  80%
-    const pytestMatch = output.match(/TOTAL\s+\d+\s+(\d+)%/);
-    if (pytestMatch?.[1]) {
-      return parseInt(pytestMatch[1], 10);
-    }
-
-    return undefined;
-  }
-
-  /**
-   * 从输出中提取失败信息
-   */
-  private extractFailures(output: string): string[] {
-    const failures: string[] = [];
-
-    // Jest 格式
-    const jestMatches = output.matchAll(/✕\s+(.+?)\s+\(/g);
-    for (const match of jestMatches) {
-      if (match[1]) failures.push(match[1]);
-    }
-
-    // Mocha 格式
-    const mochaMatches = output.matchAll(/\d+\)\s+(.+?):/g);
-    for (const match of mochaMatches) {
-      if (match[1]) failures.push(match[1]);
-    }
-
-    // pytest 格式
-    const pytestMatches = output.matchAll(/FAILED\s+(.+?)::/g);
-    for (const match of pytestMatches) {
-      if (match[1]) failures.push(match[1]);
+      const result = await execAsync(testCommand, {
+        cwd: workDir,
+        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+      });
+      output = result.stdout + result.stderr;
+    } catch (error: any) {
+      // 非零退出（超时 / buffer 溢出等执行失败也落这里）：判定依据就是退出码，文本不参与
+      exitCode = typeof error.code === 'number' ? error.code : 1;
+      output = (error.stdout || '') + '\n' + (error.stderr || '');
     }
 
-    // Go test 格式
-    const goMatches = output.matchAll(/--- FAIL:\s+(.+?)\s+\(/g);
-    for (const match of goMatches) {
-      if (match[1]) failures.push(match[1]);
-    }
+    const { passed, failures } = judgeTestRun({
+      exitCode,
+      output,
+      allowPartialPass: this.config.allowPartialPass,
+    });
 
-    return failures;
+    return {
+      passed,
+      command: testCommand,
+      output,
+      failures,
+      timestamp,
+      evidence: await this.generateEvidence(workDir, output),
+    };
   }
 
   /**
@@ -499,110 +441,6 @@ export class PassesGate {
     return this.testResults.get(taskId);
   }
 
-  // ========================================
-  // 扩展点支持（Long-Running Agents）
-  // ========================================
-
-  /**
-   * 注册的扩展列表
-   */
-  private extensions: Map<string, PassesGateExtension> = new Map();
-
-  /**
-   * 注册扩展
-   * 
-   * 用于注册额外的测试类型（如 Puppeteer E2E）
-   * 
-   * @param name 扩展名称
-   * @param extension 扩展实现
-   * 
-   * @example
-   * ```typescript
-   * const puppeteerExtension = {
-   *   name: 'puppeteer',
-   *   run: async (workDir, task) => {
-   *     // 运行 Puppeteer 测试
-   *     return { passed: true, command: 'puppeteer', ... };
-   *   }
-   * };
-   * 
-   * passesGate.registerExtension('puppeteer', puppeteerExtension);
-   * ```
-   */
-  registerExtension(name: string, extension: PassesGateExtension): void {
-    this.extensions.set(name, extension);
-  }
-
-  /**
-   * 注销扩展
-   */
-  unregisterExtension(name: string): boolean {
-    return this.extensions.delete(name);
-  }
-
-  /**
-   * 获取所有已注册的扩展名称
-   */
-  getExtensionNames(): string[] {
-    return Array.from(this.extensions.keys());
-  }
-
-  /**
-   * 运行所有测试（包括扩展测试）
-   * 
-   * @param workDir 工作目录
-   * @param task 可选的任务信息
-   * @returns 所有测试结果
-   */
-  async runAllTests(workDir: string, task?: DynamicTask): Promise<ExtensionTestResult[]> {
-    const results: ExtensionTestResult[] = [];
-
-    // 1. 运行单元测试（原有逻辑）
-    const unitTestResult = await this.runTest(workDir, task);
-    results.push(unitTestResult);
-
-    // 2. 运行所有扩展测试
-    for (const [name, extension] of this.extensions) {
-      try {
-        const extensionResult = await extension.run(workDir, task);
-        results.push({
-          ...extensionResult,
-          type: name,
-        });
-      } catch (error: any) {
-        results.push({
-          passed: false,
-          command: `${name}-extension`,
-          error: error.message,
-          type: name,
-          timestamp: new Date(),
-        });
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * 检查所有测试是否通过
-   */
-  async checkAllPasses(workDir: string, task?: DynamicTask): Promise<{
-    passed: boolean;
-    results: ExtensionTestResult[];
-    failedTypes: string[];
-  }> {
-    const results = await this.runAllTests(workDir, task);
-    const failedTypes = results
-      .filter(r => !r.passed)
-      .map(r => r.type || 'unit');
-
-    return {
-      passed: failedTypes.length === 0,
-      results,
-      failedTypes,
-    };
-  }
-
 }
 
 /**

package/src/core/validators/test-output.ts

@@ -0,0 +1,128 @@
+/**
+ * 测试产物解读——从 runner 的 stdout 读出「过了没 / 哪些失败」（ADR-0012，判定口径 ADR-0014）
+ *
+ * 纯函数，字符串进、值出，不做 IO、不跑进程。此前解析器分别 private 关在
+ * core/validators/passes-gate.ts（extractCoverage / extractFailures）与
+ * gates/acceptance.ts（parseTestOutput）体内：两处只有 jest 一个家族共同识别，用的信号
+ * 还不同（`✕` 行 vs `Test Suites:` 汇总行），同一份输出能在一处看出失败、在另一处看不出。
+ *
+ * 本模块是包内模块，不进 src/index.ts 导出面（对齐 ADR-0009 capabilities-reconcile /
+ * ADR-0011 injection-writer 先例）。
+ *
+ * #93 裁决（ADR-0014）：判定依据统一为「退出码为主 + 文本交叉否决」，收在 judgeTestRun
+ * 一处，两个门禁都只从它取结论——原 parseTestOutput（纯文本判定）删除。
+ *
+ * #94 裁决 B（ADR-0015）：本模块不读覆盖率。extractCoverage 与其唯一产出
+ * （TaskTestResult.coverage）已删除——harness 核心判定不管覆盖率执法，判覆盖率的
+ * 两处（`harness passes-gate --coverage`、performance 门禁）各自读 json-summary。
+ *
+ * extractFailures 的正则、分支顺序、返回形状逐字迁移自 ADR-0012；仍保持原样的已知粗糙处：
+ * - 一次跑完收集所有失败（首个失败即定的编排）→ #93 范围外，另票
+ *
+ * PR #117 实发修正（2026-09-08）：四个 runner 正则由「可跨行」收紧为行首锚定/行内匹配。
+ * 原 mocha 正则 /\d+\)\s+(.+?):/g 的 \s+ 跨行——绿色运行的 console 噪音里一行以
+ * 数字+")"结尾（stack 帧 checker.ts:213:23)、init 日志 (v1.3.0)）、下一行含 ":"，
+ * 就被误捕为失败用例，governance 门禁对全绿 npm test 输出误判 24 条失败（exit 0 遭
+ * judgeTestRun 文本否决）。jest ✕ / pytest FAILED / go --- FAIL: 的 \s+ 同理收紧。
+ */
+
+/**
+ * 从输出中提取失败信息
+ */
+export function extractFailures(output: string): string[] {
+  const failures: string[] = [];
+
+  // Jest 格式（✕ 与用例名同行；\s 不跨行，防把下一行日志/堆栈捕进来）
+  const jestMatches = output.matchAll(/✕[ \t]+([^\n]+?)[ \t]+\(/g);
+  for (const match of jestMatches) {
+    if (match[1]) failures.push(match[1]);
+  }
+
+  // Mocha 格式（行首锚定：「N) 标题:」必须是一行的开头形状；
+  // 旧写法不锚行首且 \s+ 跨行，绿输出的 console 噪音会被误判——见文件头 PR #117 段）
+  const mochaMatches = output.matchAll(/^[ \t]*\d+\)[ \t]+([^\n]+?):/gm);
+  for (const match of mochaMatches) {
+    if (match[1]) failures.push(match[1]);
+  }
+
+  // pytest 格式
+  const pytestMatches = output.matchAll(/FAILED[ \t]+([^\n]+?)::/g);
+  for (const match of pytestMatches) {
+    if (match[1]) failures.push(match[1]);
+  }
+
+  // Go test 格式
+  const goMatches = output.matchAll(/--- FAIL:[ \t]+([^\n]+?)[ \t]+\(/g);
+  for (const match of goMatches) {
+    if (match[1]) failures.push(match[1]);
+  }
+
+  return failures;
+}
+
+/**
+ * 判定结果：过了没，以及文本里读出的失败用例名
+ */
+export interface TestRunVerdict {
+  passed: boolean;
+  /** 用例级失败名（判负时的可定位线索；退出码非零时也照常带出） */
+  failures: string[];
+}
+
+/**
+ * 行首锚定的结构化失败信号（ADR-0014）
+ *
+ * 只认 runner 自己打的汇总/套件行，不认子串：旧 `output.includes('FAIL')` 兜底会被通过的
+ * 用例名（`✓ FAIL 时应该重试`）或含 FAIL 的目录名反转成判负。
+ * - 套件行 `FAIL src/a.test.ts`（pytest 的 `FAILED x::`、go 的 `--- FAIL:` 行首不是 FAIL，
+ *   由 extractFailures 认）
+ * - 计数汇总行：jest `Test Suites: 2 failed, ...` / `Tests: 2 failed, ...`，
+ *   playwright / mocha / pytest 的 `  1 failed` / `  1 failing` / `2 failed, 5 passed in 0.88s`。
+ *   计数为 0 是全过（`Test Suites: 0 failed, 2 total`），不构成信号
+ */
+const SUITE_FAILURE_LINE = /^FAIL\b.*$/m;
+const SUMMARY_FAILURE_COUNTS: RegExp[] = [
+  /^(?:Test Suites|Suites|Tests):\s+(\d+)\s+failed\b/m,
+  /^\s*(\d+)\s+(?:failed|failing)\b/m,
+];
+
+function hasStructuredFailure(output: string): boolean {
+  if (SUITE_FAILURE_LINE.test(output)) return true;
+
+  return SUMMARY_FAILURE_COUNTS.some(pattern => {
+    const match = pattern.exec(output);
+    return match !== null && Number(match[1]) > 0;
+  });
+}
+
+/**
+ * 判一次测试跑动的结论：退出码为主 + 文本交叉否决（#93，ADR-0014）
+ *
+ * - 退出码非零 → 判负，文本救不回来
+ * - 退出码为零但文本有结构化失败信号 → 判负（runner 退出码撒谎的兜底）
+ * - 退出码为零且无失败信号 → 判过；「没跑出测试」不在此判定的否决范围内（另票）
+ *
+ * `allowPartialPass` 的落点是**文本否决**这一维（部分通过 = 允许个别用例失败但命令本身过了）；
+ * 它不赦免非零退出码。
+ */
+export function judgeTestRun(input: {
+  /** 测试命令的退出码（0 = runner 自己说过了） */
+  exitCode: number;
+  /** runner 的 stdout + stderr 合并文本 */
+  output: string;
+  /** 允许部分通过：文本失败信号不否决零退出码，缺省 false */
+  allowPartialPass?: boolean;
+}): TestRunVerdict {
+  const failures = extractFailures(input.output);
+
+  if (input.exitCode !== 0) {
+    return { passed: false, failures };
+  }
+  if (input.allowPartialPass) {
+    return { passed: true, failures };
+  }
+
+  const vetoed = failures.length > 0 || hasStructuredFailure(input.output);
+
+  return { passed: !vetoed, failures };
+}

package/src/failure/__tests__/recorder.test.ts

@@ -0,0 +1,168 @@
+/**
+ * FailureRecorder 坏行容错测试（harness#96）
+ *
+ * fixtures 走真实临时文件（mkdtempSync，统一清理见 src/test-setup）：
+ * failures.log 夹一行坏 JSON 时，failure list|stats 不崩栈、
+ * stdout（含 --json）逐字节不变、stderr 出现一次含坏行条数的警告。
+ */
+
+import * as fs from 'fs';
+import { captureIO, type CapturingIO } from '../../cli/command-contract';
+import * as os from 'os';
+import * as path from 'path';
+import { FailureRecorder } from '../recorder';
+import { failureList, failureStats } from '../../cli/commands/failure';
+import { ErrorType, FailureLevel, DEFAULT_FAILURE_LOG_FILE } from '../../types/failure';
+
+const CORRUPT_LINE = '{"type":"TEST_FAILED","level":"L1","mess'; // 半写入截断
+
+function makeRecorder(logFile: string): FailureRecorder {
+  return new FailureRecorder({ logFile });
+}
+
+function writeLogFile(dir: string, lines: string[]): string {
+  // CLI 侧经 getRecorder 读 <projectPath>/<DEFAULT_FAILURE_LOG_FILE>，fixture 必须落在同一真实路径
+  const logFile = path.join(dir, DEFAULT_FAILURE_LOG_FILE);
+  fs.mkdirSync(path.dirname(logFile), { recursive: true });
+  fs.writeFileSync(logFile, lines.join('\n') + '\n', 'utf-8');
+  return logFile;
+}
+
+function validRecord(message: string): string {
+  return JSON.stringify({
+    type: ErrorType.TEST_FAILED,
+    level: FailureLevel.L1,
+    message,
+    timestamp: 1700000000000,
+  });
+}
+
+function captureConsole(): { stdout: string[]; stderr: string[] } {
+  const captured = { stdout: [] as string[], stderr: [] as string[] };
+  jest.spyOn(console, 'log').mockImplementation((...args: unknown[]) => {
+    captured.stdout.push(args.map(String).join(' '));
+  });
+  jest.spyOn(console, 'error').mockImplementation((...args: unknown[]) => {
+    captured.stderr.push(args.map(String).join(' '));
+  });
+  return captured;
+}
+
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
+describe('FailureRecorder 坏行容错（harness#96）', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-recorder-'));
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  describe('getHistory()', () => {
+    it('坏行不抛：返回全部合法记录', async () => {
+      const logFile = writeLogFile(dir, [validRecord('a'), CORRUPT_LINE, validRecord('b')]);
+      const records = await makeRecorder(logFile).getHistory();
+      expect(records.map(r => r.message)).toEqual(['a', 'b']);
+    });
+
+    it('跳过坏行时 stderr 出现一次含条数的警告', async () => {
+      const logFile = writeLogFile(dir, [
+        validRecord('a'),
+        CORRUPT_LINE,
+        CORRUPT_LINE,
+        validRecord('b'),
+      ]);
+      const captured = captureConsole();
+      await makeRecorder(logFile).getHistory();
+      expect(captured.stderr).toHaveLength(1);
+      expect(captured.stderr[0]).toContain('2');
+      expect(captured.stdout).toEqual([]);
+    });
+
+    it('文件不存在落到空态，无警告', async () => {
+      const captured = captureConsole();
+      const records = await makeRecorder(path.join(dir, 'missing.log')).getHistory();
+      expect(records).toEqual([]);
+      expect(captured.stderr).toEqual([]);
+    });
+
+    it('全部行损坏落到空态', async () => {
+      const logFile = writeLogFile(dir, [CORRUPT_LINE, 'not-json']);
+      const captured = captureConsole();
+      const records = await makeRecorder(logFile).getHistory();
+      expect(records).toEqual([]);
+      expect(captured.stderr).toHaveLength(1);
+    });
+
+    it('limit 只取最近 N 条合法记录', async () => {
+      const logFile = writeLogFile(dir, [validRecord('a'), CORRUPT_LINE, validRecord('b'), validRecord('c')]);
+      const records = await makeRecorder(logFile).getHistory(2);
+      expect(records.map(r => r.message)).toEqual(['b', 'c']);
+    });
+  });
+
+  describe('getStats()', () => {
+    it('统计口径只计合法记录', async () => {
+      const logFile = writeLogFile(dir, [validRecord('a'), CORRUPT_LINE, validRecord('b')]);
+      const stats = await makeRecorder(logFile).getStats();
+      expect(stats.total).toBe(2);
+    });
+  });
+
+  describe('failure list 命令', () => {
+    it('坏行不崩、stdout 与无坏行时逐字节一致、stderr 警告一次', async () => {
+      writeLogFile(path.join(dir, 'clean'), [validRecord('a'), validRecord('b')]);
+      writeLogFile(path.join(dir, 'dirty'), [validRecord('a'), CORRUPT_LINE, validRecord('b')]);
+
+      // 列表正文走注入 io；损坏行警告由 recorder 自身 console.error 打印
+      const cleanIo = captureIO();
+      await failureList({ projectPath: path.join(dir, 'clean') }, cleanIo);
+
+      const dirtyCapture = captureConsole();
+      const dirtyIo = captureIO();
+      const dirtyResult = await failureList({ projectPath: path.join(dir, 'dirty') }, dirtyIo);
+      expect(dirtyResult).toEqual({ kind: 'ok' });
+
+      expect(dirtyIo.outText()).toBe(cleanIo.outText());
+      expect(dirtyIo.outText()).not.toBe('');
+      expect(dirtyCapture.stderr).toHaveLength(1);
+      expect(dirtyCapture.stderr[0]).toContain('1');
+    });
+
+    it('--json 输出不受 stderr 警告污染且不含坏行', async () => {
+      writeLogFile(dir, [validRecord('a'), CORRUPT_LINE]);
+      const captured = captureConsole();
+      await failureList({ projectPath: dir, json: true }, io);
+
+      expect(captured.stderr).toHaveLength(1);
+      const parsed = JSON.parse(io.outText());
+      expect(parsed.total).toBe(1);
+      expect(parsed.records[0].message).toBe('a');
+    });
+  });
+
+  describe('failure stats 命令', () => {
+    it('坏行不崩、stdout 与无坏行时逐字节一致', async () => {
+      writeLogFile(path.join(dir, 'clean'), [validRecord('a'), validRecord('b')]);
+      writeLogFile(path.join(dir, 'dirty'), [CORRUPT_LINE, validRecord('a'), validRecord('b')]);
+
+      const cleanIo = captureIO();
+      await failureStats({ projectPath: path.join(dir, 'clean') }, cleanIo);
+
+      const dirtyCapture = captureConsole();
+      const dirtyIo = captureIO();
+      await failureStats({ projectPath: path.join(dir, 'dirty') }, dirtyIo);
+
+      expect(dirtyIo.outText()).toBe(cleanIo.outText());
+      expect(dirtyIo.outText()).not.toBe('');
+      expect(dirtyCapture.stderr).toHaveLength(1);
+    });
+  });
+});