@dommaker/harness 1.3.0 → 1.5.0

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

@@ -1,9 +1,13 @@
 /**
  * command 命令测试
+ *
+ * 判定经返回值断言（架构评审候选7）：退出码不再靠 spyOn(process,'exit')，
+ * 输出文本走注入 captureIO。
  */
 
 import { executeCommand } from '../command';
 import { createCommandGate, getCommandRiskLevel } from '../../../gates';
+import { captureIO, type CapturingIO } from '../../command-contract';
 
 jest.mock('../../../gates', () => ({
   createCommandGate: jest.fn(),
@@ -25,125 +29,136 @@ jest.mock('chalk', () => ({
 const mockCreateGate = createCommandGate as jest.MockedFunction<typeof createCommandGate>;
 const mockGetRisk = getCommandRiskLevel as jest.MockedFunction<typeof getCommandRiskLevel>;
 
+function mockGate(check: jest.Mock): void {
+  mockCreateGate.mockReturnValue({ check } as any);
+}
+
+/** 从捕获输出里取第一条可解析为该形状的 JSON 行 */
+function parseJsonLine(lines: string[], predicate: (parsed: any) => boolean): any {
+  for (const line of lines.join('\n').split('\n\n')) {
+    try {
+      const parsed = JSON.parse(line);
+      if (predicate(parsed)) return parsed;
+    } catch { /* 非 JSON 行 */ }
+  }
+  return undefined;
+}
+
 describe('command command', () => {
-  let consoleSpy: jest.SpyInstance;
-  let errorSpy: jest.SpyInstance;
-  let exitSpy: jest.SpyInstance;
+  let io: CapturingIO;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    errorSpy = jest.spyOn(console, 'error').mockImplementation();
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-    process.exitCode = 0;
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
-    process.exitCode = 0;
+    io = captureIO();
   });
 
   describe('--list', () => {
-    it('should list rules grouped by category', async () => {
-      await executeCommand(undefined, { list: true });
-
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('命令黑名单规则'));
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[destructive]'));
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('[database]'));
+    it('按类别分组列出规则并返回 ok', async () => {
+      const result = await executeCommand(undefined, { list: true }, io);
+
+      expect(result).toEqual({ kind: 'ok' });
+      expect(io.outText()).toContain('命令黑名单规则');
+      expect(io.outLines()).toEqual(
+        expect.arrayContaining([expect.stringContaining('[destructive]'), expect.stringContaining('[database]')]),
+      );
     });
 
-    it('should list rules as JSON when --json', async () => {
-      await executeCommand(undefined, { list: true, json: true });
+    it('--json 列出规则数组', async () => {
+      const result = await executeCommand(undefined, { list: true, json: true }, io);
 
-      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
-        try { return Array.isArray(JSON.parse(c[0])); } catch { return false; }
-      });
-      expect(jsonCall).toBeTruthy();
-      const parsed = JSON.parse(jsonCall[0]);
-      expect(parsed).toHaveLength(2);
+      expect(result).toEqual({ kind: 'ok' });
+      expect(parseJsonLine(io.outLines(), Array.isArray)).toHaveLength(2);
     });
   });
 
   describe('no command', () => {
-    it('should print error and exit 1 when no command provided', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+    it('缺参数：usage-error + 原因，并提示用法', async () => {
+      const result = await executeCommand(undefined, {}, io);
 
-      await executeCommand(undefined, {});
-
-      expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('请提供要检查的命令'));
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(result).toEqual({
+        kind: 'usage-error',
+        reason: expect.stringContaining('缺少要检查的命令参数'),
+      });
+      expect(io.errText()).toContain('请提供要检查的命令');
+      expect(io.outText()).toBe('');
     });
   });
 
   describe('default mode', () => {
-    it('should print pass when result passes', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+    it('放行：ok，打印 ✓', async () => {
+      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
 
-      await executeCommand('safe-cmd', {});
+      const result = await executeCommand('safe-cmd', {}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('✓'));
+      expect(result).toEqual({ kind: 'ok' });
+      expect(io.outText()).toContain('✓');
     });
 
-    it('should print fail and exit 1 when result fails', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: false, message: 'Blocked' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+    it('拒绝：fail + 裁决原因，打印 ✗', async () => {
+      mockGate(jest.fn().mockResolvedValue({ passed: false, message: 'Blocked' }));
 
-      await executeCommand('rm -rf /', {});
+      const result = await executeCommand('rm -rf /', {}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('✗'));
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(result).toEqual({ kind: 'fail', reason: expect.stringContaining('Blocked') });
+      expect(io.outText()).toContain('✗');
     });
 
-    it('should output JSON when --json', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK', details: {} });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+    it('--json 输出裁决详情', async () => {
+      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK', details: {} }));
 
-      await executeCommand('cmd', { json: true });
+      await executeCommand('cmd', { json: true }, io);
 
-      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
-        try { const p = JSON.parse(c[0]); return p.command !== undefined; } catch { return false; }
+      expect(parseJsonLine(io.outLines(), (p: any) => p.command === 'cmd')).toEqual({
+        command: 'cmd',
+        passed: true,
+        message: 'OK',
+        details: {},
       });
-      expect(jsonCall).toBeTruthy();
     });
   });
 
   describe('--level', () => {
-    it('should print risk level', async () => {
+    it('low：ok，打印等级', async () => {
       mockGetRisk.mockReturnValue('low');
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
 
-      await executeCommand('safe-cmd', { level: true });
+      const result = await executeCommand('safe-cmd', { level: true }, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('low'));
-      expect(exitSpy).toHaveBeenCalledWith(0);
+      expect(result).toEqual({ kind: 'ok' });
+      expect(io.outText()).toContain('low');
     });
 
-    it('should exit 1 for high risk', async () => {
+    it('high：fail + 等级原因（严重级条件式译成 kind）', async () => {
       mockGetRisk.mockReturnValue('high');
+      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
+
+      const result = await executeCommand('rm -rf /', { level: true }, io);
+
+      expect(result).toEqual({ kind: 'fail', reason: expect.stringContaining('risk level is high') });
+    });
+
+    it('high 等级不再执行黑名单裁决分支', async () => {
       const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+      mockGetRisk.mockReturnValue('high');
+      mockGate(mockCheck);
 
-      await executeCommand('rm -rf /', { level: true });
+      const result = await executeCommand('rm -rf /', { level: true }, io);
 
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      // 历史行为：--level 命中即退出，不再打印 pass/fail 行
+      expect(result.kind).toBe('fail');
+      expect(io.outText()).not.toContain('✓');
     });
 
-    it('should output JSON when --json', async () => {
+    it('--json 输出等级', async () => {
       mockGetRisk.mockReturnValue('medium');
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockCreateGate.mockReturnValue({ check: mockCheck } as any);
+      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
 
-      await executeCommand('cmd', { level: true, json: true });
+      await executeCommand('cmd', { level: true, json: true }, io);
 
-      const jsonCall = consoleSpy.mock.calls.find((c: any[]) => {
-        try { const p = JSON.parse(c[0]); return p.level !== undefined; } catch { return false; }
+      expect(parseJsonLine(io.outLines(), (p: any) => p.level !== undefined)).toEqual({
+        level: 'medium',
+        command: 'cmd',
       });
-      expect(jsonCall).toBeTruthy();
     });
   });
 });

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

@@ -8,7 +8,7 @@
  */
 
 import * as fs from 'fs';
-import * as os from 'os';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as path from 'path';
 import type { ExecutionTrace } from '../../../types/trace';
 import {
@@ -17,43 +17,24 @@ import {
   readProjectTraces,
 } from '../../../core/constraints/usage-report';
 import { constraintsReport, renderExportMarkdown } from '../constraints-report';
-
-function makeTmpProject(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'harness-report-test-'));
-}
-
-function writeTraces(root: string, traces: Partial<ExecutionTrace>[]): void {
-  const dir = path.join(root, '.harness', 'logs');
-  fs.mkdirSync(dir, { recursive: true });
-  const lines = traces.map(t =>
-    JSON.stringify({
-      level: 'guideline',
-      timestamp: 1700000000000,
-      result: 'pass',
-      ...t,
-    })
-  );
-  fs.writeFileSync(path.join(dir, 'traces.log'), lines.join('\n') + '\n', 'utf-8');
-}
+import { createProjectFixture, writeProjectTraces } from '../../../test-setup/project-fixture';
 
 /** 生成 N 条同结果 trace */
 function tracesOf(id: string, result: ExecutionTrace['result'], n: number, startTs = 1700000000000): Partial<ExecutionTrace>[] {
   return Array.from({ length: n }, (_, i) => ({ constraintId: id, result, timestamp: startTs + i * 1000 }));
 }
 
-let logSpy: jest.SpyInstance;
-
 beforeEach(() => {
-  logSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
 });
 
-afterEach(() => {
-  logSpy.mockRestore();
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
 });
 
 describe('buildConstraintsUsageReport', () => {
   it('无 trace 文件：生效集 check 约束全部列出且 total=0，全部判为零触发候选', () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     const report = buildConstraintsUsageReport(root);
 
     expect(report.traceFileExists).toBe(false);
@@ -72,8 +53,7 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('空 trace 文件：与无文件一致，但 traceFileExists=true', () => {
-    const root = makeTmpProject();
-    writeTraces(root, []);
+    const root = createProjectFixture({ name: 'harness-report-test', traces: [] });
     const report = buildConstraintsUsageReport(root);
 
     expect(report.traceFileExists).toBe(true);
@@ -82,8 +62,8 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('含 skip 的统计：skip 不计入 fail 率分母，首次/最近时间正确', () => {
-    const root = makeTmpProject();
-    writeTraces(root, [
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeProjectTraces(root, [
       ...tracesOf('no_hardcoded_credentials', 'pass', 3, 1700000000000),
       ...tracesOf('no_hardcoded_credentials', 'fail', 1, 1700000100000),
       ...tracesOf('no_hardcoded_credentials', 'skip', 2, 1700000200000),
@@ -104,7 +84,7 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('坏行容错：单行 JSON 损坏不影响其他行统计', () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     const dir = path.join(root, '.harness', 'logs');
     fs.mkdirSync(dir, { recursive: true });
     fs.writeFileSync(
@@ -116,8 +96,8 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('四类候选诊断：零触发/不可评估(flag)/不可评估(探测)/高噪/零拦截', () => {
-    const root = makeTmpProject();
-    writeTraces(root, [
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeProjectTraces(root, [
       // 不可评估（flag 未接线）：全部 skip
       ...tracesOf('no_completion_without_verification', 'skip', 3),
       // 不可评估（存在性探测未命中）：全部 skip
@@ -156,8 +136,10 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('阈值可配：放宽零拦截样本阈值后 10 次全 pass 也成为候选', () => {
-    const root = makeTmpProject();
-    writeTraces(root, tracesOf('no_hardcoded_credentials', 'pass', 10));
+    const root = createProjectFixture({
+      name: 'harness-report-test',
+      traces: tracesOf('no_hardcoded_credentials', 'pass', 10),
+    });
 
     const strict = buildConstraintsUsageReport(root);
     expect(strict.candidates.find(c => c.id === 'no_hardcoded_credentials')).toBeUndefined();
@@ -179,13 +161,10 @@ describe('buildConstraintsUsageReport', () => {
   });
 
   it('配置健康：config.yml 中未知 id 进入 unknownIds', () => {
-    const root = makeTmpProject();
-    fs.mkdirSync(path.join(root, '.harness'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, '.harness', 'config.yml'),
-      'constraints:\n  ghost_constraint:\n    enabled: false\n',
-      'utf-8'
-    );
+    const root = createProjectFixture({
+      name: 'harness-report-test',
+      config: 'constraints:\n  ghost_constraint:\n    enabled: false\n',
+    });
     const report = buildConstraintsUsageReport(root);
     expect(report.lint.unknownIds).toContain('ghost_constraint');
   });
@@ -193,18 +172,15 @@ describe('buildConstraintsUsageReport', () => {
 
 describe('constraintsReport CLI', () => {
   it('console 输出包含统计表、候选、注入清单、unknownIds 提示', async () => {
-    const root = makeTmpProject();
-    fs.mkdirSync(path.join(root, '.harness'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, '.harness', 'config.yml'),
-      'constraints:\n  ghost_constraint:\n    enabled: false\n',
-      'utf-8'
-    );
-    writeTraces(root, tracesOf('no_hardcoded_credentials', 'pass', 3));
+    const root = createProjectFixture({
+      name: 'harness-report-test',
+      config: 'constraints:\n  ghost_constraint:\n    enabled: false\n',
+      traces: tracesOf('no_hardcoded_credentials', 'pass', 3),
+    });
 
-    await constraintsReport({ projectPath: root });
+    await constraintsReport({ projectPath: root }, io);
 
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain('约束使用报告');
     expect(output).toContain('no_hardcoded_credentials');
     expect(output).toContain('total=3');
@@ -214,14 +190,14 @@ describe('constraintsReport CLI', () => {
   });
 
   it('--export 缺省路径：写入 .harness/reports/constraints-<YYYYMMDD>.md 且内容脱敏', async () => {
-    const root = makeTmpProject();
-    writeTraces(root, [
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeProjectTraces(root, [
       ...tracesOf('no_bypass_checkpoint', 'fail', 20),
       // projectPath 字段进 trace，但不得进 export
       { constraintId: 'no_bypass_checkpoint', result: 'fail', projectPath: root, timestamp: 1700001000000 },
     ]);
 
-    await constraintsReport({ projectPath: root, export: true });
+    await constraintsReport({ projectPath: root, export: true }, io);
 
     const date = new Date().toISOString().slice(0, 10).replace(/-/g, '');
     const exportPath = path.join(root, '.harness', 'reports', `constraints-${date}.md`);
@@ -237,19 +213,19 @@ describe('constraintsReport CLI', () => {
     expect(content).not.toContain('projectPath');
 
     // 打印了导出路径
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain(exportPath);
   });
 
   it('--export 指定文件：写到给定路径', async () => {
-    const root = makeTmpProject();
-    await constraintsReport({ projectPath: root, export: 'my-report.md' });
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    await constraintsReport({ projectPath: root, export: 'my-report.md' }, io);
     expect(fs.existsSync(path.join(root, 'my-report.md'))).toBe(true);
   });
 
   it('renderExportMarkdown：无候选时显式标注', () => {
-    const root = makeTmpProject();
-    writeTraces(root, [
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeProjectTraces(root, [
       // 所有 check 约束给少量健康数据（低于一切阈值）
       ...buildConstraintsUsageReport(root).stats.flatMap(s => tracesOf(s.id, 'pass', 5)),
     ]);
@@ -262,6 +238,59 @@ describe('constraintsReport CLI', () => {
   });
 });
 
+describe('constraintsReport 坏行数透传（harness#100）', () => {
+  /** 直接落原始行（含坏行）——writeProjectTraces 只写合法记录，构造不出损坏 fixture */
+  function writeRawTraces(root: string, lines: string[]): void {
+    const dir = path.join(root, '.harness', 'logs');
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(path.join(dir, 'traces.log'), lines.join('\n') + '\n', 'utf-8');
+  }
+
+  const healthyTrace = (id: string) =>
+    JSON.stringify({ constraintId: id, level: 'iron_law', timestamp: 1700000000000, result: 'pass' });
+  const BAD = '{"constraintId":"ghost","broken';
+
+  it('坏行 fixture：文本输出出现坏行数提示，--json 报告体带 skippedLines', async () => {
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeRawTraces(root, [healthyTrace('no_hardcoded_credentials'), BAD, BAD]);
+
+    await constraintsReport({ projectPath: root }, io);
+    expect(io.outText()).toContain('2 行损坏');
+
+    const jsonIo = captureIO();
+    await constraintsReport({ projectPath: root, json: true }, jsonIo);
+    expect(JSON.parse(jsonIo.outText()).skippedLines).toBe(2);
+  });
+
+  it('traceFileExists=true 且无损坏：零噪声（无坏行提示，既有文案不变）', async () => {
+    const root = createProjectFixture({ name: 'harness-report-test' });
+    writeRawTraces(root, [healthyTrace('no_hardcoded_credentials')]);
+
+    await constraintsReport({ projectPath: root }, io);
+
+    const output = io.outText();
+    expect(output).toContain('约束使用报告');
+    expect(output).not.toContain('损坏');
+    expect(output).not.toContain('trace 文件不存在');
+  });
+
+  it('--export 摘要同样带坏行数（脱敏：只报条数，不报路径与坏行内容）', async () => {
+    const dirty = createProjectFixture({ name: 'harness-report-test' });
+    writeRawTraces(dirty, [healthyTrace('no_hardcoded_credentials'), BAD]);
+    await constraintsReport({ projectPath: dirty, export: 'report.md' }, captureIO());
+
+    const dirtyMd = fs.readFileSync(path.join(dirty, 'report.md'), 'utf-8');
+    expect(dirtyMd).toContain('1 行损坏');
+    expect(dirtyMd).not.toContain(BAD);
+    expect(dirtyMd).not.toContain(dirty);
+
+    const clean = createProjectFixture({ name: 'harness-report-test' });
+    writeRawTraces(clean, [healthyTrace('no_hardcoded_credentials')]);
+    await constraintsReport({ projectPath: clean, export: 'report.md' }, captureIO());
+    expect(fs.readFileSync(path.join(clean, 'report.md'), 'utf-8')).not.toContain('损坏');
+  });
+});
+
 describe('constraintsReport 注入漂移小节（ADR-0001 决策 7）', () => {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const realVersion = require('../../../../package.json').version as string;
@@ -274,7 +303,7 @@ describe('constraintsReport 注入漂移小节（ADR-0001 决策 7）', () => {
   };
 
   it('有漂移：输出条目级差异（缺失/多余）与修复指引', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     writeSyncedClaudeMd(root, '0.0.1-old');
     const claudeMdPath = path.join(root, 'CLAUDE.md');
     const content = fs.readFileSync(claudeMdPath, 'utf-8');
@@ -282,9 +311,9 @@ describe('constraintsReport 注入漂移小节（ADR-0001 决策 7）', () => {
     const editedLine = originalLine.replace(/: .+$/, ': 手工篡改');
     fs.writeFileSync(claudeMdPath, content.replace(originalLine, editedLine), 'utf-8');
 
-    await constraintsReport({ projectPath: root });
+    await constraintsReport({ projectPath: root }, io);
 
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain('注入漂移');
     expect(output).toContain('版本漂移');
     expect(output).toContain('0.0.1-old');
@@ -294,34 +323,34 @@ describe('constraintsReport 注入漂移小节（ADR-0001 决策 7）', () => {
   });
 
   it('重复章节：输出重复章节提示', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     writeSyncedClaudeMd(root);
     fs.appendFileSync(path.join(root, 'CLAUDE.md'), '\n## Governance Rules\n\n旧版遗留\n', 'utf-8');
 
-    await constraintsReport({ projectPath: root });
+    await constraintsReport({ projectPath: root }, io);
 
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain('重复章节');
   });
 
   it('无漂移：小节显示无漂移', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     writeSyncedClaudeMd(root);
 
-    await constraintsReport({ projectPath: root });
+    await constraintsReport({ projectPath: root }, io);
 
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain('注入漂移');
     expect(output).toContain('无漂移');
   });
 
   it('未注入（无标记段）：一句话提示，不算漂移', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-report-test' });
     fs.writeFileSync(path.join(root, 'CLAUDE.md'), '# Test Project\n', 'utf-8');
 
-    await constraintsReport({ projectPath: root });
+    await constraintsReport({ projectPath: root }, io);
 
-    const output = logSpy.mock.calls.map(c => String(c[0])).join('\n');
+    const output = io.outText();
     expect(output).toContain('未注入');
   });
 });