@dommaker/harness 1.3.0 → 1.5.0

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

@@ -3,6 +3,7 @@
  */
 
 import { acceptance, listAcceptanceCriteria } from '../acceptance';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 import { SpecAcceptanceGate } from '../../../gates/acceptance';
 
@@ -35,20 +36,12 @@ const MockGate = SpecAcceptanceGate as jest.MockedClass<typeof SpecAcceptanceGat
 const yaml = require('js-yaml');
 
 describe('acceptance command', () => {
-  let consoleSpy: jest.SpyInstance;
-  let exitSpy: jest.SpyInstance;
+  let io: CapturingIO;
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-    process.exitCode = 0;
-  });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-    process.exitCode = 0;
+    io = captureIO();
+    jest.clearAllMocks();
   });
 
   describe('acceptance', () => {
@@ -60,10 +53,10 @@ describe('acceptance command', () => {
       });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({});
+      const result = await acceptance({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('验收标准检查通过'));
-      expect(exitSpy).not.toHaveBeenCalled();
+      expect(io.outText()).toContain('验收标准检查通过');
+      expect(result.kind).toBe('ok');
     });
 
     it('should print failure and exit 1 when check fails', async () => {
@@ -74,27 +67,33 @@ describe('acceptance command', () => {
       });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({});
+      const result = await acceptance({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('验收标准检查失败'));
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(io.outText()).toContain('验收标准检查失败');
+      expect(result).toEqual({
+        kind: 'fail',
+        reason: 'acceptance gate denied: criteria not met',
+      });
     });
 
     it('should handle errors and exit 1', async () => {
       const mockCheck = jest.fn().mockRejectedValue(new Error('gate error'));
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({});
+      const result = await acceptance({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('验收标准检查出错'));
-      expect(exitSpy).toHaveBeenCalledWith(1);
+      expect(io.outText()).toContain('验收标准检查出错');
+      expect(result).toEqual({
+        kind: 'fail',
+        reason: 'acceptance gate error: gate error',
+      });
     });
 
     it('should use cwd as default projectPath', async () => {
       const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({});
+      await acceptance({}, io);
 
       expect(mockCheck).toHaveBeenCalledWith(
         expect.objectContaining({ projectPath: process.cwd() }),
@@ -105,7 +104,7 @@ describe('acceptance command', () => {
       const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({ taskId: 'TASK-001' });
+      await acceptance({ taskId: 'TASK-001' }, io);
 
       expect(mockCheck).toHaveBeenCalledWith(
         expect.objectContaining({ taskId: 'TASK-001' }),
@@ -116,7 +115,7 @@ describe('acceptance command', () => {
       const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({ runE2e: true });
+      await acceptance({ runE2e: true }, io);
 
       expect(MockGate).toHaveBeenCalledWith(
         expect.objectContaining({ e2eTestCommand: 'npx playwright test' }),
@@ -127,7 +126,7 @@ describe('acceptance command', () => {
       const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
       MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-      await acceptance({});
+      await acceptance({}, io);
 
       expect(MockGate).toHaveBeenCalledWith(
         expect.objectContaining({ e2eTestCommand: undefined }),
@@ -143,10 +142,10 @@ describe('acceptance command', () => {
         'task-2': { acceptanceCriteria: ['Criteria A'] },
       });
 
-      await listAcceptanceCriteria({});
+      await listAcceptanceCriteria({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('task-1'));
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Criteria 1'));
+      expect(io.outText()).toContain('task-1');
+      expect(io.outText()).toContain('Criteria 1');
     });
 
     it('should handle task with no criteria', async () => {
@@ -155,26 +154,34 @@ describe('acceptance command', () => {
         'task-1': {},
       });
 
-      await listAcceptanceCriteria({});
+      await listAcceptanceCriteria({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('无验收标准'));
+      expect(io.outText()).toContain('无验收标准');
     });
 
     it('should handle empty tasks object', async () => {
       mockFs.readFile.mockResolvedValue('yaml-content');
       yaml.load.mockReturnValue(null);
 
-      await listAcceptanceCriteria({});
+      const result = await listAcceptanceCriteria({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未找到任务定义'));
+      expect(io.outText()).toContain('未找到任务定义');
+      expect(result).toEqual({
+        kind: 'skip',
+        reason: expect.stringContaining('未找到任务定义'),
+      });
     });
 
     it('should handle file read error', async () => {
       mockFs.readFile.mockRejectedValue(new Error('ENOENT'));
 
-      await listAcceptanceCriteria({});
+      const result = await listAcceptanceCriteria({}, io);
 
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('读取 tasks.yml 失败'));
+      expect(io.outText()).toContain('读取 tasks.yml 失败');
+      expect(result).toEqual({
+        kind: 'skip',
+        reason: expect.stringContaining('读取 tasks.yml 失败'),
+      });
     });
   });
 });

package/src/cli/commands/__tests__/analyze-sessions.test.ts

@@ -9,6 +9,7 @@
  */
 
 import * as fs from 'fs';
+import { captureIO, lastJsonOutput, type CapturingIO } from '../../command-contract';
 import * as path from 'path';
 import { analyzeSessions } from '../analyze-sessions';
 import { readTranscriptSessions, type MinedSession } from '../../session-mining';
@@ -69,13 +70,12 @@ function mkSession(partial: Partial<MinedSession> = {}): MinedSession {
   };
 }
 
-function lastJsonOutput(consoleSpy: jest.SpyInstance): Record<string, unknown> {
-  const jsonLine = consoleSpy.mock.calls.map(c => c[0]).join('\n');
-  return JSON.parse(jsonLine);
-}
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
 
 describe('analyze-sessions command', () => {
-  let consoleSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
@@ -83,42 +83,48 @@ describe('analyze-sessions command', () => {
     fs.mkdirSync(path.join(TEST_HOME, '.claude', 'projects', '-root-projects', 'memory'), { recursive: true });
     fs.mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
     process.env.CLAUDE_TRANSCRIPTS_DIR = TRANSCRIPTS_DIR;
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
   });
 
   afterEach(() => {
-    consoleSpy.mockRestore();
     delete process.env.CLAUDE_TRANSCRIPTS_DIR;
   });
 
   test('transcripts 目录不存在：提示 No transcripts directory found', async () => {
     process.env.CLAUDE_TRANSCRIPTS_DIR = path.join(TEST_HOME, 'missing-dir');
 
-    await analyzeSessions({});
+    const result = await analyzeSessions({}, io);
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No transcripts directory found'));
+    expect(io.outText()).toContain('No transcripts directory found');
+    expect(result).toEqual({ kind: 'skip', reason: expect.stringContaining('会话记录目录不存在') });
     expect(mockReadTranscriptSessions).not.toHaveBeenCalled();
   });
 
   test('窗口内无会话：提示 No sessions found（默认最近 7 天）', async () => {
-    mockReadTranscriptSessions.mockReturnValue([
-      mkSession({ id: 'old', mtimeMs: Date.now() - 30 * 86_400_000 }),
-    ]);
-
-    await analyzeSessions({});
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('No sessions found in the last 7 days'));
+    const before = Date.now() - 7 * 86_400_000;
+    mockReadTranscriptSessions.mockReturnValue([]);
+
+    const result = await analyzeSessions({}, io);
+    const after = Date.now() - 7 * 86_400_000;
+
+    expect(io.outText()).toContain('No sessions found in the last 7 days');
+    expect(result).toEqual({ kind: 'skip', reason: '最近 7 天没有会话' });
+    // since 过滤下推到 seam：默认窗口 7 天
+    const filter = mockReadTranscriptSessions.mock.calls[0][1] as { since?: number };
+    expect(filter.since).toBeGreaterThanOrEqual(before);
+    expect(filter.since).toBeLessThanOrEqual(after);
   });
 
-  test('--days 1：只统计最近 1 天（mtimeMs 窗口过滤）', async () => {
-    mockReadTranscriptSessions.mockReturnValue([
-      mkSession({ id: 'today' }),
-      mkSession({ id: 'two-days-ago', mtimeMs: Date.now() - 2 * 86_400_000 }),
-    ]);
+  test('--days 1：since 过滤下推到 seam（mtimeMs 窗口）', async () => {
+    const before = Date.now() - 86_400_000;
+    mockReadTranscriptSessions.mockReturnValue([mkSession({ id: 'today' })]);
 
-    await analyzeSessions({ days: 1 });
+    await analyzeSessions({ days: 1 }, io);
+    const after = Date.now() - 86_400_000;
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Analyzing 1 sessions (last 1 days)'));
+    expect(io.outText()).toContain('Analyzing 1 sessions (last 1 days)');
+    const filter = mockReadTranscriptSessions.mock.calls[0][1] as { since?: number };
+    expect(filter.since).toBeGreaterThanOrEqual(before);
+    expect(filter.since).toBeLessThanOrEqual(after);
   });
 
   test('缺省 --days：窗口为 7 天，两天前会话仍计入', async () => {
@@ -127,9 +133,9 @@ describe('analyze-sessions command', () => {
       mkSession({ id: 'two-days-ago', mtimeMs: Date.now() - 2 * 86_400_000 }),
     ]);
 
-    await analyzeSessions({});
+    await analyzeSessions({}, io);
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Analyzing 2 sessions (last 7 days)'));
+    expect(io.outText()).toContain('Analyzing 2 sessions (last 7 days)');
   });
 
   test('--json：纠正句跨 3 会话聚合为 correction 候选', async () => {
@@ -139,9 +145,9 @@ describe('analyze-sessions command', () => {
       mkSession({ id: 's3' }),
     ]);
 
-    await analyzeSessions({ json: true });
+    await analyzeSessions({ json: true }, io);
 
-    const output = lastJsonOutput(consoleSpy);
+    const output = lastJsonOutput(io);
     expect(output.sessions).toBe(3);
     expect(output.corrections).toBe(3);
     expect(output.candidates).toEqual(
@@ -168,9 +174,9 @@ describe('analyze-sessions command', () => {
       }),
     ]);
 
-    await analyzeSessions({ json: true });
+    await analyzeSessions({ json: true }, io);
 
-    const output = lastJsonOutput(consoleSpy);
+    const output = lastJsonOutput(io);
     const ngramCandidates = (output.candidates as Array<{ source: string }>)
       .filter(c => c.source === 'ngram');
     expect(ngramCandidates.length).toBeGreaterThan(0);

package/src/cli/commands/__tests__/bin-exit-mapping.test.ts

@@ -0,0 +1,107 @@
+/**
+ * bin 侧退出码映射测试（架构评审候选7）
+ *
+ * 命令实现只返回 CommandResult，`process.exit` 的唯一出口在 bin/harness.js。
+ * 两层证据：
+ * 1. exitCodeFor 纯映射：四种 kind + 契约违规（未知/缺失 kind）fail-closed；
+ * 2. 端到端 spawn bin/harness.js（dist 存在时）：真实命令的对外退出码
+ *    ——断言进程 status，不用 spyOn(process,'exit')。
+ * 另加零 process.exit 的源码护栏（命令实现/定义表目录）。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawnSync } from 'child_process';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { exitCodeFor } = require('../../../../bin/harness.js');
+
+const repoRoot = path.join(__dirname, '..', '..', '..', '..');
+const distBin = path.join(repoRoot, 'bin', 'harness.js');
+const distCommands = path.join(repoRoot, 'dist', 'cli', 'commands');
+const hasDist = fs.existsSync(distCommands);
+
+describe('exitCodeFor：kind → 退出码唯一映射', () => {
+  it('ok / skip → 0（现状对外码面只有 0/1，skip 不新增码值）', () => {
+    expect(exitCodeFor({ kind: 'ok' })).toBe(0);
+    expect(exitCodeFor({ kind: 'skip' })).toBe(0);
+    expect(exitCodeFor({ kind: 'skip', reason: '没有定义检查点' })).toBe(0);
+  });
+
+  it('fail / usage-error → 1', () => {
+    expect(exitCodeFor({ kind: 'fail', reason: 'gate branch: 非 master' })).toBe(1);
+    expect(exitCodeFor({ kind: 'usage-error', reason: '缺少关键词' })).toBe(1);
+  });
+
+  it('未知或缺失 kind → fail-closed（命令契约违规不得静默通过）', () => {
+    const errSpy = jest.spyOn(console, 'error').mockImplementation();
+    try {
+      expect(exitCodeFor({ kind: 'exploded' })).toBe(1);
+      expect(exitCodeFor(undefined)).toBe(1);
+      expect(exitCodeFor({})).toBe(1);
+      expect(errSpy).toHaveBeenCalledTimes(3);
+    } finally {
+      errSpy.mockRestore();
+    }
+  });
+});
+
+describe('命令实现/定义表目录零 process.exit（唯一出口在 bin）', () => {
+  const dirs = [
+    path.join(repoRoot, 'src', 'cli', 'commands'),
+    path.join(repoRoot, 'src', 'cli', 'commands', 'sync-docs'),
+  ];
+
+  it.each(dirs.map(d => [d]))('%s', (dir: string) => {
+    const offenders = fs.readdirSync(dir)
+      .filter(f => f.endsWith('.ts') && !f.includes('.test.'))
+      .filter(f => fs.readFileSync(path.join(dir, f), 'utf-8').includes('process.exit'))
+      .map(f => `${dir}/${f}`);
+    expect(offenders).toEqual([]);
+  });
+
+  it('bin/harness.js 只有一处 process.exit 调用点', () => {
+    const source = fs.readFileSync(distBin, 'utf-8');
+    const calls = [...source.matchAll(/process\.exit\(/g)];
+    expect(calls).toHaveLength(1);
+  });
+});
+
+// CI 上 dist 缺失时显式失败而非静默 skip（harness#99）：#86 退出语义的
+// 唯一端到端证据在下面的 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 映射后的对外退出码', () => {
+  const run = (argv: string[]) => spawnSync(process.execPath, [distBin, ...argv], {
+    cwd: repoRoot,
+    encoding: 'utf-8',
+    timeout: 60000,
+  });
+
+  it('放行命令 → 0（返回 ok，进程自然退出）', () => {
+    const r = run(['command', 'ls']);
+    expect(r.status).toBe(0);
+  });
+
+  it('门禁否决 → 1（返回 fail，bin 映射）', () => {
+    const r = run(['command', 'rm -rf /']);
+    expect(r.status).toBe(1);
+    expect(r.stdout).toContain('✗');
+  });
+
+  it('用法错误 → 1（返回 usage-error）', () => {
+    const r = run(['kb', 's']);
+    expect(r.status).toBe(1);
+    expect(r.stderr).toContain('请提供搜索关键词');
+  });
+
+  it('bin 自身子命令路由错误 → 1', () => {
+    const r = run(['knowledge', 'bogus']);
+    expect(r.status).toBe(1);
+    expect(r.stderr).toContain('未知子命令: bogus');
+  });
+});

package/src/cli/commands/__tests__/check-drift.test.ts

@@ -7,18 +7,23 @@
  */
 
 import * as fs from 'fs';
-import * as os from 'os';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as path from 'path';
 import { check } from '../check';
-import { constraintChecker } from '../../../core/constraints/checker';
 import { renderConstraintsSection } from '../../../core/constraints/injection-renderer';
 import { getEffectiveConstraints } from '../../../core/effective-constraints';
+import { createProjectFixture } from '../../../test-setup/project-fixture';
 
+// 命令 per-run 构造 checker（harness#88）：构造替身即控制 checkConstraints 返回值
+const mockChecker = { checkConstraints: jest.fn() };
 jest.mock('../../../core/constraints/checker', () => ({
-  constraintChecker: {
-    setTraceRecorder: jest.fn(),
-    checkConstraints: jest.fn(),
-  },
+  ConstraintChecker: jest.fn(function () {
+    return mockChecker;
+  }),
+}));
+
+jest.mock('../../../monitoring/traces', () => ({
+  getTraceCollector: jest.fn(() => ({ record: jest.fn() })),
 }));
 
 jest.mock('../../../utils/exec', () => ({
@@ -30,15 +35,9 @@ jest.mock('child_process', () => ({
   execSync: jest.fn(() => Buffer.from('')),
 }));
 
-const mockChecker = constraintChecker as jest.Mocked<typeof constraintChecker>;
-
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const REAL_VERSION = require('../../../../package.json').version as string;
 
-function makeTmpProject(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'harness-check-drift-test-'));
-}
-
 function writeClaudeMd(root: string, version: string): void {
   const section =
     '## Governance Rules\n' + renderConstraintsSection(getEffectiveConstraints(root), version);
@@ -46,13 +45,12 @@ function writeClaudeMd(root: string, version: string): void {
 }
 
 describe('check 命令注入漂移警告', () => {
-  let consoleSpy: jest.SpyInstance;
-  let exitSpy: jest.SpyInstance;
+  let io: CapturingIO;
 
   beforeEach(() => {
+
+    io = captureIO();
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
     mockChecker.checkConstraints.mockResolvedValue({
       passed: true,
       ironLaws: [],
@@ -61,18 +59,13 @@ describe('check 命令注入漂移警告', () => {
     });
   });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    exitSpy.mockRestore();
-  });
-
-  const outputText = () => consoleSpy.mock.calls.map(c => String(c[0])).join('\n');
+  const outputText = () => io.outText();
 
   it('版本漂移：黄色警告块 + ⚠️⚠️ 版本行，但不阻断（exit 未调用，仍判通过）', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-check-drift-test' });
     writeClaudeMd(root, '0.0.1-old');
 
-    await check({ preset: 'standard', staged: false, projectPath: root });
+    const result = await check({ preset: 'standard', staged: false, projectPath: root }, io);
 
     const output = outputText();
     expect(output).toContain('约束注入漂移');
@@ -82,43 +75,43 @@ describe('check 命令注入漂移警告', () => {
     expect(output).toContain('npx @dommaker/harness init');
     // 不阻断：检查仍通过、未调用 process.exit
     expect(output).toContain('约束检查通过');
-    expect(exitSpy).not.toHaveBeenCalled();
+    expect(result.kind).toBe('ok');
   });
 
   it('内容漂移：手改一条 → 警告块含缺失/多余计数，exit 未调用', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-check-drift-test' });
     writeClaudeMd(root, REAL_VERSION);
     const claudeMdPath = path.join(root, 'CLAUDE.md');
     const content = fs.readFileSync(claudeMdPath, 'utf-8');
     const originalLine = content.split('\n').find(l => l.startsWith('- **'))!;
     fs.writeFileSync(claudeMdPath, content.replace(originalLine, originalLine.replace(/: .+$/, ': 篡改')), 'utf-8');
 
-    await check({ preset: 'standard', staged: false, projectPath: root });
+    const result = await check({ preset: 'standard', staged: false, projectPath: root }, io);
 
     const output = outputText();
     expect(output).toContain('内容漂移: 缺失 1 条 / 多余 1 条');
     expect(output).toContain('约束检查通过');
-    expect(exitSpy).not.toHaveBeenCalled();
+    expect(result.kind).toBe('ok');
   });
 
   it('无漂移：零警告输出（不增加噪音）', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-check-drift-test' });
     writeClaudeMd(root, REAL_VERSION);
 
-    await check({ preset: 'standard', staged: false, projectPath: root });
+    const result = await check({ preset: 'standard', staged: false, projectPath: root }, io);
 
     const output = outputText();
     expect(output).not.toContain('注入漂移');
     expect(output).toContain('约束检查通过');
-    expect(exitSpy).not.toHaveBeenCalled();
+    expect(result.kind).toBe('ok');
   });
 
   it('未注入（无 CLAUDE.md）：不警告', async () => {
-    const root = makeTmpProject();
+    const root = createProjectFixture({ name: 'harness-check-drift-test' });
 
-    await check({ preset: 'standard', staged: false, projectPath: root });
+    const result = await check({ preset: 'standard', staged: false, projectPath: root }, io);
 
     expect(outputText()).not.toContain('注入漂移');
-    expect(exitSpy).not.toHaveBeenCalled();
+    expect(result.kind).toBe('ok');
   });
 });

package/src/cli/commands/__tests__/check-skip-output.test.ts

@@ -5,7 +5,7 @@
  */
 
 import { check } from '../check';
-import { constraintChecker } from '../../../core/constraints/checker';
+import { captureIO, type CapturingIO } from '../../command-contract';
 
 // Mock fs
 jest.mock('fs', () => ({
@@ -26,12 +26,16 @@ jest.mock('child_process', () => ({
   execSync: jest.fn(() => Buffer.from('')),
 }));
 
-// Mock constraintChecker
+// Mock checker：命令 per-run 构造 checker（harness#88），构造替身即控 checkConstraints 返回值
+const mockChecker = { checkConstraints: jest.fn() };
 jest.mock('../../../core/constraints/checker', () => ({
-  constraintChecker: {
-    setTraceRecorder: jest.fn(),
-    checkConstraints: jest.fn(),
-  },
+  ConstraintChecker: jest.fn(function () {
+    return mockChecker;
+  }),
+}));
+
+jest.mock('../../../monitoring/traces', () => ({
+  getTraceCollector: jest.fn(() => ({ record: jest.fn() })),
 }));
 
 // Mock effective-constraints（ADR-0001：check 经 getMergedConstraintsConfig 走生效集链路）
@@ -55,8 +59,6 @@ jest.mock('chalk', () => ({
   red: jest.fn((str: string) => str),
 }));
 
-const mockChecker = constraintChecker as jest.Mocked<typeof constraintChecker>;
-
 function fakeConstraint(id: string, level: 'iron_law' | 'guideline') {
   return {
     kind: 'check' as const,
@@ -70,17 +72,12 @@ function fakeConstraint(id: string, level: 'iron_law' | 'guideline') {
 }
 
 describe('check 命令 skip 输出', () => {
-  let consoleSpy: jest.SpyInstance;
+  let io: CapturingIO;
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    process.exitCode = 0;
-  });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    process.exitCode = 0;
+    io = captureIO();
+    jest.clearAllMocks();
   });
 
   it('skipped 单独列示，不计入铁律通过条数', async () => {
@@ -94,15 +91,15 @@ describe('check 命令 skip 输出', () => {
       warningCount: 0,
     });
 
-    await check({ preset: 'default', staged: false });
+    await check({ preset: 'default', staged: false }, io);
 
     // 通过条数只计实际评估的 1 条
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('铁律: 全部通过 (1 条)'));
+    expect(io.outText()).toContain('铁律: 全部通过 (1 条)');
     // skipped 单独列示
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('跳过评估: 1 条'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('- law_skip'));
+    expect(io.outText()).toContain('跳过评估: 1 条');
+    expect(io.outText()).toContain('- law_skip');
     // skip 不影响整体通过
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('约束检查通过'));
+    expect(io.outText()).toContain('约束检查通过');
   });
 
   it('指导原则通过计数排除 skipped', async () => {
@@ -116,9 +113,9 @@ describe('check 命令 skip 输出', () => {
       warningCount: 0,
     });
 
-    await check({ preset: 'default', staged: false });
+    await check({ preset: 'default', staged: false }, io);
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('指导原则: 1/1 通过'));
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('跳过评估: 1 条'));
+    expect(io.outText()).toContain('指导原则: 1/1 通过');
+    expect(io.outText()).toContain('跳过评估: 1 条');
   });
 });