@dommaker/harness 1.3.0 → 1.5.0

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

@@ -36,7 +36,7 @@ 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',
-  'doc-freshness-check', 'spec-baseline-check',
+  'spec-baseline-check',
   // 6 门禁命令（GATE_DEFINITIONS 驱动）
   'acceptance', 'command', 'contract', 'performance', 'review', 'security',
 ];
@@ -66,6 +66,28 @@ describe('命令注册表闭环', () => {
     }
   });
 
+  it('全部命令实现声明 CommandResult 返回（候选7：判定经返回值外溢）', () => {
+    const refs = collectRefs([
+      ...COMMAND_DEFINITIONS,
+      ...GATE_DEFINITIONS.map(d => d.cli),
+    ]);
+    for (const ref of refs) {
+      const file = fs.existsSync(path.join(repoCommandsDir, ref.module + '.ts'))
+        ? path.join(repoCommandsDir, ref.module + '.ts')
+        : path.join(repoCommandsDir, ref.module, 'index.ts');
+      const source = fs.readFileSync(file, 'utf-8');
+      const declAt = source.search(new RegExp(`function\\s+${ref.export}\\s*\\(`));
+      expect(declAt).toBeGreaterThanOrEqual(0);
+      const decl = source.slice(declAt, declAt + 900);
+      expect(decl).toMatch(/\)\s*:\s*(?:Promise<)?CommandResult/);
+      // bin 的调用约定：任何路由/子命令/action 至少传 options（mapActionArgs 编组）
+      // → 首参不得是 io，否则 options 会被当成 io 传入（写流即崩，退出码 1）
+      const params = source.slice(declAt + ref.export.length, declAt + 900);
+      const firstParam = (params.slice(params.indexOf('(') + 1).match(/^\s*([A-Za-z_$][\w$]*)/) || [''])[1];
+      expect(['io', '_io']).not.toContain(firstParam);
+    }
+  });
+
   it('顶层命令面与预期 24 命令一致（含 6 门禁）', () => {
     const names = [
       ...COMMAND_DEFINITIONS.map(d => d.command.split(' ')[0]),
@@ -80,45 +102,42 @@ describe('命令注册表闭环', () => {
     expect(new Set(names).size).toBe(names.length);
   });
 
-  it('全部命令定义的路由构造可执行（mapActionArgs/subcommands.args/optionRoutes.args/afterRun 冒烟）', () => {
-    const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-    try {
-      const walk = (def: CommandDefinition) => {
-        if (def.mapActionArgs) {
-          def.mapActionArgs(['positional'], {});
-          def.mapActionArgs([], {});
+  it('子命令别名唯一：别名不与主名/其他别名碰撞（候选7：别名是数据，冲突即行为歧义）', () => {
+    const walk = (def: CommandDefinition) => {
+      const entries = Object.entries(def.subcommands || {});
+      const seen = new Set<string>();
+      for (const [name, entry] of entries) {
+        expect(seen.has(name)).toBe(false);
+        seen.add(name);
+        for (const alias of entry.aliases || []) {
+          expect(seen.has(alias)).toBe(false);
+          seen.add(alias);
         }
-        for (const entry of Object.values(def.subcommands || {})) {
-          if (entry.args) {
-            entry.args(['positional'], {});
-            entry.args([], {});
-          }
-        }
-        for (const route of def.optionRoutes || []) {
-          if (route.args) {
-            route.args([], {});
-            route.args(['positional'], {});
-          }
-        }
-        if (def.afterRun) {
-          def.afterRun(true, {});
-          def.afterRun(false, { check: true });
-        }
-        for (const child of def.children || []) walk(child);
-      };
-      for (const def of [
-        ...COMMAND_DEFINITIONS,
-        ...GATE_DEFINITIONS.map(d => d.cli),
-      ]) walk(def);
-      // sync-docs --check 失败路径确实会请求退出
-      expect(exitSpy).toHaveBeenCalled();
-    } finally {
-      exitSpy.mockRestore();
-    }
+      }
+      for (const child of def.children || []) walk(child);
+    };
+    for (const def of [...COMMAND_DEFINITIONS, ...GATE_DEFINITIONS.map(d => d.cli)]) walk(def);
+  });
+
+  it('全部命令定义的路由构造可执行（mapActionArgs 冒烟；候选7 后定义表零副作用闭包）', () => {
+    const walk = (def: CommandDefinition) => {
+      if (def.mapActionArgs) {
+        def.mapActionArgs(['positional'], {});
+        def.mapActionArgs([], {});
+      }
+      // 候选7：定义表不得再持有退出码处理闭包（afterRun 已废除，判定进返回值）
+      expect((def as unknown as Record<string, unknown>).afterRun).toBeUndefined();
+      for (const child of def.children || []) walk(child);
+    };
+    for (const def of [
+      ...COMMAND_DEFINITIONS,
+      ...GATE_DEFINITIONS.map(d => d.cli),
+    ]) walk(def);
   });
 });
 
 const repoRoot = path.join(__dirname, '..', '..', '..', '..');
+const repoCommandsDir = path.join(repoRoot, 'src', 'cli', 'commands');
 const distBin = path.join(repoRoot, 'bin', 'harness.js');
 const distCommands = path.join(repoRoot, 'dist', 'cli', 'commands');
 const hasDist = fs.existsSync(distCommands);
@@ -156,6 +175,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 存在时）', () => {
@@ -200,4 +225,19 @@ smoke('bin/harness.js 端到端（dist 存在时）', () => {
     expect(r.status).toBe(1);
     expect(r.stderr).toContain('未知子命令: bogus');
   });
+
+  it('别名子命令解析到同一实现（knowledge ls = list，候选7）', () => {
+    const r = runWithModuleProbe(['knowledge', 'ls', '--json']);
+    expect(r.status).toBe(0);
+    expect(JSON.parse(r.stdout)).toHaveProperty('total');
+    expect(r.implModules).toEqual([
+      expect.stringContaining('/dist/cli/commands/knowledge.js'),
+    ]);
+  });
+
+  it('search 编组闸门随别名命令名生效且提示逐字不变（kb s 缺参 → exit 1）', () => {
+    const r = runWithModuleProbe(['kb', 's']);
+    expect(r.status).toBe(1);
+    expect(r.stderr).toContain('请提供搜索关键词');
+  });
 });

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

@@ -1,19 +1,22 @@
 /**
- * release 命令测试（O6）
+ * release 命令测试（O6 + 架构评审候选7）
  *
- * Seam：release(options) 公开入口。
+ * Seam：release(options, io) 公开入口。
  * 隔离面：
- *   - child_process.execSync → 按命令分发的 fixture（git/npm/tsc 全部 mock，绝不真执行）
+ *   - child_process.execSync → 按命令前缀分发的 fixture（git/npm/tsc 全部 mock，绝不真执行）
  *   - fs.existsSync / readFileSync → fixture 包（package.json + dist 关键文件）
- *   - process.exit → 抛异常断言化（exit code 可断言，且阻断后续真实副作用）
+ *   - 输出 → 注入 captureIO（不再 spyOn(process,'exit') / 断言彩色字符串）
  *
- * 测试止于 dry-run 与「发布前闸门」（分支/同步/干净树/tag 冲突），
- * 不覆盖真实 npm version/publish 路径——禁止真发版。
+ * 判定结果经返回值外溢：每个前置闸门的失败原因含闸门标识（gate <id>），
+ * 测试断言 kind + reason + 「首败即停」（后续闸门副作用未发生）。
+ *
+ * 测试止于 dry-run 与「发布前闸门」，不覆盖真实 npm version/publish 路径——禁止真发版。
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import { execSync } from 'child_process';
+import { captureIO, type CapturingIO } from '../../../cli/command-contract';
 import { release } from '../release';
 
 jest.mock('child_process', () => ({
@@ -62,22 +65,53 @@ const PKG_JSON = JSON.stringify({
   exports: { '.': './dist/index.js' },
 });
 
+/** 抛一个带 stderr 的子进程失败（execSync 失败对象的形状） */
+function fail(cmd: string, stderr = cmd): never {
+  const err: any = new Error(`${cmd} exited`);
+  err.stderr = stderr;
+  throw err;
+}
+
+type Override = [prefix: string, handler: (cmd: string) => string];
+
+/**
+ * 全闸门通过的默认流（master / 已同步 / 干净树 / tsc ok / dist ok /
+ * npm version → v0.18.1 / npm view → 0.18.1），overrides 按前缀优先命中。
+ */
+function flow(overrides: Override[] = []): void {
+  mockExecSync.mockImplementation((cmd) => {
+    const c = String(cmd);
+    for (const [prefix, handler] of overrides) {
+      if (c.startsWith(prefix)) return handler(c);
+    }
+    if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
+    if (c.startsWith('git rev-list --count')) return '0';
+    if (c.startsWith('git status --porcelain')) return '';
+    if (c.startsWith('git tag -l')) return '';
+    if (c.startsWith('npx tsc')) return 'build ok';
+    if (c.startsWith('npm version')) return 'v0.18.1';
+    if (c.startsWith('npm view')) return '0.18.1';
+    return '';
+  });
+}
+
+function execCommands(): string[] {
+  return mockExecSync.mock.calls.map(c => String(c[0]));
+}
+
+/** 断言 fail 结果的 reason 定位到指定闸门 */
+function gateFail(gate: string) {
+  return { kind: 'fail' as const, reason: expect.stringContaining(`gate ${gate}`) };
+}
+
 describe('release command', () => {
-  let consoleSpy: jest.SpyInstance;
-  let errorSpy: jest.SpyInstance;
-  let exitSpy: jest.SpyInstance;
+  let io: CapturingIO;
   let pkgExists: boolean;
-  let tagListResult: string;
 
   beforeEach(() => {
     jest.clearAllMocks();
+    io = captureIO();
     pkgExists = true;
-    tagListResult = '';
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-    errorSpy = jest.spyOn(console, 'error').mockImplementation();
-    exitSpy = jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null) => {
-      throw new Error(`__exit_${code}__`);
-    });
 
     mockFs.existsSync.mockImplementation((p) => {
       if (String(p).endsWith('package.json')) return pkgExists;
@@ -85,99 +119,194 @@ describe('release command', () => {
     });
     mockFs.readFileSync.mockReturnValue(PKG_JSON);
 
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '0';
-      if (c.startsWith('git status --porcelain')) return '';
-      if (c.startsWith('git tag -l')) return tagListResult;
-      if (c.startsWith('npx tsc')) return 'build ok';
-      return '';
-    });
+    flow();
   });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-    errorSpy.mockRestore();
-    exitSpy.mockRestore();
+  test('闸门 1 非包目录：fail 定位 package 闸门，零子进程调用', async () => {
+    pkgExists = false;
+
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('package'));
+    expect(io.errLines().join('\n')).toContain('Not a package');
+    expect(execCommands()).toEqual([]);
   });
 
-  test('非包目录：exit 1 并提示 Not a package', async () => {
-    pkgExists = false;
+  test('闸门 2 非 master/main 分支：fail 定位 branch 闸门，后续闸门不执行', async () => {
+    flow([['git rev-parse --abbrev-ref', () => 'feat/x']]);
+
+    const result = await release({}, io);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Not a package'));
+    expect(result).toEqual(gateFail('branch'));
+    expect(io.errText()).toContain('Must be on master or main branch');
+    const commands = execCommands();
+    expect(commands.some(c => c.startsWith('git fetch'))).toBe(false);
+    expect(commands.some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('非 master/main 分支：exit 1 并提示', async () => {
-    mockExecSync.mockImplementation((cmd: string) =>
-      String(cmd).startsWith('git rev-parse --abbrev-ref') ? 'feat/x' : '');
+  test('闸门 3 落后于远程：fail 定位 remote-sync 闸门', async () => {
+    flow([['git rev-list --count', () => '3']]);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Must be on master or main branch'));
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('remote-sync'));
+    expect(io.errText()).toContain('behind origin');
+    expect(execCommands().some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('落后于远程：exit 1 并提示 behind', async () => {
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '3';
-      return '';
-    });
+  test('闸门 4 工作树不干净：fail 定位 clean-tree 闸门', async () => {
+    flow([['git status --porcelain', () => ' M package.json']]);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('behind origin'));
+    const result = await release({}, io);
+
+    expect(result).toEqual(gateFail('clean-tree'));
+    expect(io.errText()).toContain('Uncommitted changes');
+    expect(execCommands().some(c => c.startsWith('npx tsc'))).toBe(false);
   });
 
-  test('工作树不干净：exit 1 并提示 Uncommitted changes', async () => {
-    mockExecSync.mockImplementation((cmd: string) => {
-      const c = String(cmd);
-      if (c.startsWith('git rev-parse --abbrev-ref')) return 'master';
-      if (c.startsWith('git rev-list --count')) return '0';
-      if (c.startsWith('git status --porcelain')) return ' M package.json';
-      return '';
-    });
+  test('闸门 5 tsc 构建失败：fail 定位 build 闸门', async () => {
+    flow([['npx tsc', (c) => fail(c, 'error TS2304: cannot find name')]]);
+
+    const result = await release({}, io);
 
-    await expect(release({})).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Uncommitted changes'));
+    expect(result).toEqual(gateFail('build'));
+    expect(io.errText()).toContain('tsc failed');
+    expect(io.errText()).toContain('TS2304');
   });
 
-  test('dist 关键发布物缺失：发布前闸门 exit 1（不触 npm version）', async () => {
+  test('闸门 6 dist 关键发布物缺失：fail 定位 dist-artifacts 闸门（不触 npm version）', async () => {
     mockFs.existsSync.mockImplementation((p) => {
       if (String(p).endsWith('package.json')) return true;
       if (String(p).includes(`${path.sep}dist${path.sep}`)) return false;
       return true;
     });
 
-    await expect(release({ bumpType: 'patch' })).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('dist missing critical artifacts'));
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('dist/index.js'));
-    const commands = mockExecSync.mock.calls.map(c => String(c[0]));
-    expect(commands.some(c => c.startsWith('npm version'))).toBe(false);
-  });
+    const result = await release({ bumpType: 'patch' }, io);
 
-  test('dry-run patch：计算目标版本 0.18.1，exit 0', async () => {
-    await expect(release({ bumpType: 'patch', dryRun: 'true' })).rejects.toThrow('__exit_0__');
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Dry-run complete. Would publish: @dommaker/harness@0.18.1'),
-    );
+    expect(result).toEqual(gateFail('dist-artifacts'));
+    expect(io.errText()).toContain('dist missing critical artifacts');
+    expect(io.errText()).toContain('dist/index.js');
+    expect(execCommands().some(c => c.startsWith('npm version'))).toBe(false);
   });
 
-  test('dry-run minor：计算目标版本 0.19.0', async () => {
-    await expect(release({ bumpType: 'minor', dryRun: 'true' })).rejects.toThrow('__exit_0__');
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Dry-run complete. Would publish: @dommaker/harness@0.19.0'),
-    );
+  test.each([
+    ['patch', '0.18.1'],
+    ['minor', '0.19.0'],
+    ['major', '1.0.0'],
+  ] as const)('dry-run %s：ok 且提示目标版本 %s（不触 npm version）', async (bumpType, expected) => {
+    const result = await release({ bumpType, dryRun: 'true' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain(`Dry-run complete. Would publish: @dommaker/harness@${expected}`);
+    expect(execCommands().some(c => c.startsWith('npm version'))).toBe(false);
   });
 
-  test('目标 tag 已存在：发布前闸门 exit 1（不触 npm version）', async () => {
-    tagListResult = 'v0.18.1';
+  test('闸门 7 目标 tag 已存在：fail 定位 tag-conflict 闸门（不触 npm version/publish）', async () => {
+    flow([['git tag -l', () => 'v0.18.1']]);
+
+    const result = await release({ bumpType: 'patch' }, io);
 
-    await expect(release({ bumpType: 'patch' })).rejects.toThrow('__exit_1__');
-    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('already exists'));
-    // 闸门阻断：npm version / npm publish 从未执行
-    const commands = mockExecSync.mock.calls.map(c => String(c[0]));
+    expect(result).toEqual(gateFail('tag-conflict'));
+    expect(io.errText()).toContain('already exists');
+    const commands = execCommands();
     expect(commands.some(c => c.startsWith('npm version'))).toBe(false);
     expect(commands.some(c => c.startsWith('npm publish'))).toBe(false);
   });
+
+  test('闸门 8 npm version 失败：fail 定位 version-bump 闸门（不触 push）', async () => {
+    flow([['npm version', (c) => fail(c, 'npm ERR! Version prefix required')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('version-bump'));
+    expect(io.errText()).toContain('npm version failed');
+    expect(execCommands().some(c => c.startsWith('git push'))).toBe(false);
+  });
+
+  test('闸门 9 git push 失败（非保护分支）：fail 定位 git-push 闸门', async () => {
+    flow([['git push origin master', (c) => fail(c, 'error: failed to push some refs')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('git-push'));
+    expect(io.errText()).toContain('git push failed');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 10 保护分支且 PR 创建失败：fail 定位 pr-create 闸门', async () => {
+    flow([
+      ['git push origin master', (c) => fail(c, 'GH006: push rejected to protected branch')],
+      ['gh pr create', (c) => fail(c, 'could not create pull request')],
+    ]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('pr-create'));
+    expect(io.errText()).toContain('PR creation failed');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('保护分支且 PR 创建成功：ok（不走 npm publish，打印后续步骤）', async () => {
+    flow([
+      ['git push origin master', (c) => fail(c, 'GH006: push rejected to protected branch')],
+      ['gh pr create', () => 'https://github.com/x/y/pull/9'],
+    ]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain('PR created: https://github.com/x/y/pull/9');
+    expect(io.outText()).toContain('Next steps');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 11 package.json private=true：fail 定位 private-flag 闸门（不触 npm publish）', async () => {
+    mockFs.readFileSync.mockReturnValue(JSON.stringify({
+      name: '@dommaker/harness',
+      version: '0.18.0',
+      private: true,
+      main: './dist/index.js',
+    }));
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('private-flag'));
+    expect(io.errText()).toContain('"private": true');
+    expect(execCommands().some(c => c.startsWith('npm publish'))).toBe(false);
+  });
+
+  test('闸门 12 npm 版本校验不一致：fail 定位 npm-publish-verify 闸门', async () => {
+    flow([['npm view', () => '0.0.1']]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual(gateFail('npm-publish-verify'));
+    expect(io.errText()).toContain('npm publish verification failed');
+    expect(io.errText()).toContain('Expected 0.18.1, registry has 0.0.1');
+  });
+
+  test('发布全流程通过：ok，GitHub Release 失败为非致命告警', async () => {
+    flow([['gh release create', (c) => fail(c, 'gh: could not generate notes')]]);
+
+    const result = await release({ bumpType: 'patch' }, io);
+
+    expect(result).toEqual({ kind: 'ok' });
+    expect(io.outText()).toContain('Released @dommaker/harness@0.18.1');
+    expect(io.outText()).toContain('release may have failed (non-fatal)');
+    expect(io.outText()).toContain('npm: published @dommaker/harness@0.18.1');
+  });
+
+  test('闸门标识唯一且覆盖全部前置闸门（失败原因可逐闸门断言）', () => {
+    // 本文件 mock 了 fs，读源码要走真实 fs
+    const source: string = jest.requireActual('fs').readFileSync(path.join(__dirname, '..', 'release.ts'), 'utf-8');
+    expect(source).toContain('export async function release');
+    const gateIds = [...source.matchAll(/gateFail\('([a-z0-9-]+)'/g)].map(m => m[1]);
+    expect(gateIds.length).toBeGreaterThanOrEqual(12);
+    expect(new Set(gateIds).size).toBe(gateIds.length);
+    expect(gateIds).toEqual(expect.arrayContaining([
+      'package', 'branch', 'remote-sync', 'clean-tree', 'build', 'dist-artifacts',
+      'tag-conflict', 'version-bump', 'git-push', 'pr-create', 'private-flag', 'npm-publish-verify',
+    ]));
+    expect(source).not.toContain('process.exit');
+  });
 });

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

@@ -3,6 +3,7 @@
  */
 
 import { report } from '../report';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 
 // Mock fs/promises
@@ -19,30 +20,29 @@ jest.mock('chalk', () => ({
 
 const mockFs = fs as jest.Mocked<typeof fs>;
 
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
 describe('report command - 补充覆盖', () => {
-  let consoleSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-  });
-
-  afterEach(() => {
-    consoleSpy.mockRestore();
   });
 
   describe('format 边界情况', () => {
     it('未知格式应该默认输出 JSON', async () => {
-      await report({ format: 'json' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      const output = io.outText();
       expect(output).toContain('timestamp');
     });
   });
 
   describe('Markdown 报告完整内容', () => {
     it('Markdown 报告应该包含所有区块', async () => {
-      await report({ format: 'markdown' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'markdown' }, io);
+      const output = io.outText();
 
       expect(output).toContain('# Harness 检查报告');
       expect(output).toContain('## 约束检查');
@@ -54,8 +54,8 @@ describe('report command - 补充覆盖', () => {
 
   describe('HTML 报告完整内容', () => {
     it('HTML 报告应该包含所有区块', async () => {
-      await report({ format: 'html' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'html' }, io);
+      const output = io.outText();
 
       expect(output).toContain('<!DOCTYPE html>');
       expect(output).toContain('<title>Harness 检查报告</title>');
@@ -68,22 +68,22 @@ describe('report command - 补充覆盖', () => {
     it('Markdown 输出到文件', async () => {
       mockFs.writeFile.mockResolvedValue(undefined);
 
-      await report({ format: 'markdown', output: 'report.md' });
+      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' });
+      await report({ format: 'html', output: 'report.html' }, io);
       expect(mockFs.writeFile).toHaveBeenCalledWith('report.html', expect.stringContaining('<!DOCTYPE html>'), 'utf-8');
     });
   });
 
   describe('JSON 报告内容', () => {
     it('JSON 应该包含完整数据结构', async () => {
-      await report({ format: 'json' });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      await report({ format: 'json' }, io);
+      const output = io.outText();
       const jsonStart = output.indexOf('{');
       const jsonStr = output.slice(jsonStart);
       const data = JSON.parse(jsonStr);