@dommaker/harness 1.2.3 → 1.4.0

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

@@ -3,6 +3,7 @@
  */
 
 import { knowledgeAudit, knowledgeStats, knowledgeHealth, knowledgeSearch } from '../knowledge';
+import { captureIO, type CapturingIO } from '../../command-contract';
 
 // Mock chalk
 jest.mock('chalk', () => ({
@@ -20,6 +21,8 @@ jest.mock('../../../knowledge/audit', () => ({
   KnowledgeAudit: jest.fn().mockImplementation(() => ({
     run: mockRun,
   })),
+  // label 正本在 audit.ts 规则定义上，CLI 直接消费（#109）
+  AUDIT_RULE_LABELS: jest.requireActual('../../../knowledge/audit').AUDIT_RULE_LABELS,
 }));
 
 // Mock KnowledgeIndexGenerator (avoids real fs writes in CLI tests)
@@ -67,14 +70,24 @@ const MOCK_REPORT = {
   healthScore: { before: 95, after: 95 },
 };
 
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
 describe('getKnowledgeDir', () => {
+  const fs = require('fs');
   const os = require('os');
   const path = require('path');
   const storeModule = require('../../../knowledge/store');
   let storeCtorSpy: jest.SpyInstance;
+  let homedirSpy: jest.SpyInstance;
+  let tmpHome: string;
 
   beforeEach(() => {
     delete process.env.KNOWLEDGE_BASE_DIR;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-kdir-'));
+    homedirSpy = jest.spyOn(os, 'homedir').mockReturnValue(tmpHome);
     storeCtorSpy = jest.spyOn(storeModule, 'FileKnowledgeStore').mockImplementation(() => ({
       list: jest.fn().mockReturnValue([]),
     }));
@@ -82,27 +95,51 @@ describe('getKnowledgeDir', () => {
 
   afterEach(() => {
     storeCtorSpy.mockRestore();
+    homedirSpy.mockRestore();
     delete process.env.KNOWLEDGE_BASE_DIR;
+    fs.rmSync(tmpHome, { recursive: true, force: true });
   });
 
   it('should use KNOWLEDGE_BASE_DIR env var when set', async () => {
     process.env.KNOWLEDGE_BASE_DIR = '/custom/knowledge';
-    await knowledgeStats({ json: true });
+    await knowledgeStats({ json: true }, io);
     expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
       baseDir: '/custom/knowledge',
     }));
   });
 
-  it('should default to ~/.studio/knowledge when no env var', async () => {
-    const expected = path.join(os.homedir(), '.studio', 'knowledge');
-    await knowledgeStats({ json: true });
+  it('should default to ~/.harness/knowledge when no env var and no legacy data', async () => {
+    await knowledgeStats({ json: true }, io);
+    expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
+      baseDir: path.join(tmpHome, '.harness', 'knowledge'),
+    }));
+  });
+
+  it('should keep legacy ~/.studio/knowledge when it still has data, with deprecation notice shown once', async () => {
+    const legacyDir = path.join(tmpHome, '.studio', 'knowledge');
+    fs.mkdirSync(legacyDir, { recursive: true });
+    fs.writeFileSync(path.join(legacyDir, 'guideline-x.md'), 'data');
+    await knowledgeStats({ json: true }, io);
     expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
-      baseDir: expected,
+      baseDir: legacyDir,
+    }));
+    expect(io.errText()).toContain('旧目录');
+    // 闩锁：同进程重复解析只提示一次
+    await knowledgeStats({ json: true }, io);
+    const notices = io.errLines().filter(line => line.includes('旧目录'));
+    expect(notices).toHaveLength(1);
+  });
+
+  it('should ignore legacy dir when it exists but is empty', async () => {
+    fs.mkdirSync(path.join(tmpHome, '.studio', 'knowledge'), { recursive: true });
+    await knowledgeStats({ json: true }, io);
+    expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
+      baseDir: path.join(tmpHome, '.harness', 'knowledge'),
     }));
   });
 
   it('should use projectPath when provided', async () => {
-    await knowledgeStats({ projectPath: '/my/project', json: true });
+    await knowledgeStats({ projectPath: '/my/project', json: true }, io);
     expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
       baseDir: '/my/project/.harness/knowledge',
     }));
@@ -110,81 +147,105 @@ describe('getKnowledgeDir', () => {
 });
 
 describe('knowledgeAudit CLI', () => {
-  let consoleSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
     mockRun.mockReturnValue(MOCK_REPORT);
   });
 
-  afterEach(() => {
-    consoleSpy.mockRestore();
-  });
-
   it('should output JSON when --json is set', async () => {
-    await knowledgeAudit({ json: true });
-    expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(MOCK_REPORT, null, 2));
+    await knowledgeAudit({ json: true }, io);
+
+    expect(io.outText()).toBe(JSON.stringify(MOCK_REPORT, null, 2) + '\n');
   });
 
   it('should call audit.run with autoFix=true when --fix is set', async () => {
-    await knowledgeAudit({ fix: true });
+    await knowledgeAudit({ fix: true }, io);
     expect(mockRun).toHaveBeenCalledWith({ autoFix: true });
   });
 
   it('should call audit.run with autoFix falsy when --dry-run is set', async () => {
-    await knowledgeAudit({ dryRun: true });
+    await knowledgeAudit({ dryRun: true }, io);
     expect(mockRun).toHaveBeenCalledWith({ autoFix: undefined });
   });
 
   it('should call audit.run with autoFix falsy by default', async () => {
-    await knowledgeAudit({});
+    await knowledgeAudit({}, io);
     expect(mockRun).toHaveBeenCalledWith({ autoFix: undefined });
   });
 
   it('should display total entries and health score', async () => {
-    await knowledgeAudit({});
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeAudit({}, io);
+    const output = io.outText();
     expect(output).toContain('总条目: 100');
     expect(output).toContain('95/100');
   });
 
   it('should display dimension scores', async () => {
-    await knowledgeAudit({});
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeAudit({}, io);
+    const output = io.outText();
     expect(output).toContain('D1 结构完整性');
     expect(output).toContain('D6 飞轮验证');
   });
 
   it('should display autoFixed count when > 0', async () => {
     mockRun.mockReturnValue({ ...MOCK_REPORT, autoFixed: 5, healthScore: { before: 90, after: 95 } });
-    await knowledgeAudit({ fix: true });
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeAudit({ fix: true }, io);
+    const output = io.outText();
     expect(output).toContain('自动修复: 5');
     expect(output).toContain('修复后: 95/100');
   });
 
   it('should pass custom dir to KnowledgeAudit', async () => {
     const { KnowledgeAudit } = require('../../../knowledge/audit');
-    await knowledgeAudit({ dir: '/custom/path' });
+    await knowledgeAudit({ dir: '/custom/path' }, io);
     expect(KnowledgeAudit).toHaveBeenCalledWith(expect.objectContaining({
       baseDir: '/custom/path',
     }));
   });
+
+  it('规则 label 闭环：event-noise / deprecated-domain 显示中文 label，不回落英文键名（#109）', async () => {
+    mockRun.mockReturnValue({
+      ...MOCK_REPORT,
+      issues: [],
+      summary: {
+        ...MOCK_REPORT.summary,
+        'event-noise': 2,
+        'deprecated-domain': 1,
+      },
+    });
+    await knowledgeAudit({}, io);
+    const output = io.outText();
+    expect(output).toContain('运维事件噪音: 2');
+    expect(output).toContain('废弃领域残留: 1');
+    expect(output).not.toContain('event-noise');
+    expect(output).not.toContain('deprecated-domain');
+  });
+
+  it('维度 label 闭环：incremental 维度显示中文 label，不回落英文键名（#109）', async () => {
+    mockRun.mockReturnValue({
+      ...MOCK_REPORT,
+      dimensions: {
+        ...MOCK_REPORT.dimensions,
+        incremental: { score: 80, issues: 0, details: {} },
+      },
+    });
+    await knowledgeAudit({}, io);
+    const output = io.outText();
+    expect(output).toContain('D7 增量存活');
+    expect(output).not.toContain('incremental');
+  });
 });
 
 describe('knowledgeHealth CLI', () => {
   const storeModule = require('../../../knowledge/store');
-  let consoleSpy: jest.SpyInstance;
   let storeSpy: jest.SpyInstance;
 
   beforeEach(() => {
     jest.clearAllMocks();
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
   });
 
   afterEach(() => {
-    consoleSpy.mockRestore();
     if (storeSpy) storeSpy.mockRestore();
   });
 
@@ -197,8 +258,8 @@ describe('knowledgeHealth CLI', () => {
       getBaseDir: jest.fn().mockReturnValue('/tmp/knowledge'),
     }));
 
-    await knowledgeHealth({ json: true });
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeHealth({ json: true }, io);
+    const output = io.outText();
     const parsed = JSON.parse(output);
     expect(parsed).toHaveProperty('healthScore');
     expect(parsed.summary).toHaveProperty('total', 2);
@@ -212,8 +273,8 @@ describe('knowledgeHealth CLI', () => {
       getBaseDir: jest.fn().mockReturnValue('/tmp/knowledge'),
     }));
 
-    await knowledgeHealth({ json: true });
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeHealth({ json: true }, io);
+    const output = io.outText();
     const parsed = JSON.parse(output);
     expect(parsed.summary.lowRefEntries).toBe(1);
   });
@@ -227,8 +288,8 @@ describe('knowledgeHealth CLI', () => {
       getBaseDir: jest.fn().mockReturnValue('/tmp/knowledge'),
     }));
 
-    await knowledgeHealth({ json: true });
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeHealth({ json: true }, io);
+    const output = io.outText();
     const parsed = JSON.parse(output);
     expect(parsed.summary.staleEntries).toBe(1);
   });
@@ -247,7 +308,6 @@ describe('knowledgeSearch CLI (harness#63)', () => {
 
   let tmpProject: string;
   let knowledgeDir: string;
-  let consoleSpy: jest.SpyInstance;
 
   const FILLER_COUNT = 25; // 25 × ~800 tokens ≈ 20000 > maxTokens 10000
   const TARGET_ID = 'PIT-020';
@@ -279,7 +339,6 @@ describe('knowledgeSearch CLI (harness#63)', () => {
     tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-k63-'));
     knowledgeDir = path.join(tmpProject, '.harness', 'knowledge');
     fs.mkdirSync(knowledgeDir, { recursive: true });
-    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
 
     const store = new FileKnowledgeStore({ baseDir: knowledgeDir });
     // 高成熟度 + 有 lastReferenced 的填充条目排在前面，吃满 token budget
@@ -301,13 +360,12 @@ describe('knowledgeSearch CLI (harness#63)', () => {
   });
 
   afterEach(() => {
-    consoleSpy.mockRestore();
     fs.rmSync(tmpProject, { recursive: true, force: true });
   });
 
   async function searchJson(query: string, limit: number): Promise<any> {
-    await knowledgeSearch(query, { projectPath: tmpProject, json: true, limit });
-    const output = consoleSpy.mock.calls.map((c: any[]) => c[0]).join('\n');
+    await knowledgeSearch(query, { projectPath: tmpProject, json: true, limit }, io);
+    const output = io.outText();
     return JSON.parse(output);
   }
 

package/src/cli/commands/__tests__/passes-gate.test.ts

@@ -3,6 +3,7 @@
  */
 
 import { runPassesGate, checkCoverage } from '../passes-gate';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 import { PassesGate } from '../../../core/validators/passes-gate';
 import { execAsync } from '../../../utils/exec';
@@ -18,9 +19,10 @@ jest.mock('../../../utils/exec', () => ({
   execAsync: jest.fn(),
 }));
 
-// Mock PassesGate
+// Mock PassesGate（detectTestCommand 用真实实现——它就是收口后的正本，fs 已被 mock 喂料）
 jest.mock('../../../core/validators/passes-gate', () => ({
   PassesGate: jest.fn(),
+  detectTestCommand: jest.requireActual('../../../core/validators/passes-gate').detectTestCommand,
 }));
 
 // Mock chalk
@@ -37,17 +39,12 @@ const MockPassesGate = PassesGate as jest.MockedClass<typeof PassesGate>;
 const mockExecAsync = execAsync as jest.MockedFunction<typeof execAsync>;
 
 describe('passes-gate command', () => {
-  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();
   });
 
   describe('runPassesGate', () => {
@@ -55,8 +52,8 @@ describe('passes-gate command', () => {
       mockFs.readFile.mockRejectedValue(new Error('no package.json'));
       mockFs.access.mockRejectedValue(new Error('no file'));
 
-      await runPassesGate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未检测到测试命令'));
+      await runPassesGate({}, io);
+      expect(io.outText()).toContain('未检测到测试命令');
     });
 
     it('应该通过测试门控', async () => {
@@ -76,8 +73,8 @@ describe('passes-gate command', () => {
         runTests: mockRunTests,
       }));
 
-      await runPassesGate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('测试门控通过'));
+      await runPassesGate({}, io);
+      expect(io.outText()).toContain('测试门控通过');
     });
 
     it('应该失败测试门控', async () => {
@@ -98,11 +95,10 @@ describe('passes-gate command', () => {
       }));
 
       // Mock process.exit
-      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
 
-      await runPassesGate({});
-      expect(mockExit).toHaveBeenCalledWith(1);
-      mockExit.mockRestore();
+      const result = await runPassesGate({}, io);
+
+      expect(result).toEqual({ kind: 'fail', reason: 'passes-gate denied: 2/10 个测试失败' });
     });
 
     it('应该处理测试执行错误', async () => {
@@ -115,11 +111,9 @@ describe('passes-gate command', () => {
         runTests: mockRunTests,
       }));
 
-      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+      const result = await runPassesGate({}, io);
 
-      await runPassesGate({});
-      expect(mockExit).toHaveBeenCalledWith(1);
-      mockExit.mockRestore();
+      expect(result).toEqual({ kind: 'fail', reason: expect.stringContaining('测试执行异常: test failed') });
     });
 
     it('应该使用自定义测试命令', async () => {
@@ -135,7 +129,7 @@ describe('passes-gate command', () => {
         runTests: mockRunTests,
       }));
 
-      await runPassesGate({ testCommand: 'pytest' });
+      await runPassesGate({ testCommand: 'pytest' }, io);
       expect(MockPassesGate).toHaveBeenCalledWith(
         expect.objectContaining({ testCommand: 'pytest' })
       );
@@ -143,34 +137,37 @@ describe('passes-gate command', () => {
   });
 
   describe('checkCoverage', () => {
-    it('应该返回 true 当覆盖率达标', async () => {
+    it('覆盖率达标：ok', async () => {
       mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
       mockFs.readFile.mockResolvedValue(JSON.stringify({
         total: { lines: { pct: 85 } },
       }));
 
-      const result = await checkCoverage('/project', 80);
-      expect(result).toBe(true);
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('覆盖率达标'));
+      const result = await checkCoverage('/project', 80, io);
+
+      expect(result).toEqual({ kind: 'ok' });
+      expect(io.outText()).toContain('覆盖率达标');
     });
 
-    it('应该返回 false 当覆盖率不足', async () => {
+    it('覆盖率不足：skip（历史面：--coverage 路由不改退出码）', async () => {
       mockExecAsync.mockResolvedValue({ stdout: '', stderr: '' });
       mockFs.readFile.mockResolvedValue(JSON.stringify({
         total: { lines: { pct: 60 } },
       }));
 
-      const result = await checkCoverage('/project', 80);
-      expect(result).toBe(false);
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('覆盖率不足'));
+      const result = await checkCoverage('/project', 80, io);
+
+      expect(result).toEqual({ kind: 'skip', reason: '覆盖率不足: 60% < 80%' });
+      expect(io.outText()).toContain('覆盖率不足');
     });
 
-    it('应该返回 true 当执行出错时', async () => {
+    it('取不到覆盖率：skip（不阻断）', async () => {
       mockExecAsync.mockRejectedValue(new Error('command failed'));
 
-      const result = await checkCoverage('/project');
-      expect(result).toBe(true);
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('无法获取覆盖率信息'));
+      const result = await checkCoverage('/project', 80, io);
+
+      expect(result).toEqual({ kind: 'skip', reason: expect.stringContaining('无法获取覆盖率信息') });
+      expect(io.outText()).toContain('无法获取覆盖率信息');
     });
 
     it('应该使用默认阈值 80', async () => {
@@ -180,7 +177,8 @@ describe('passes-gate command', () => {
       }));
 
       const result = await checkCoverage('/project');
-      expect(result).toBe(true);
+
+      expect(result).toEqual({ kind: 'ok' });
     });
 
     it('应该处理 coverage.total 为 undefined', async () => {
@@ -188,7 +186,8 @@ describe('passes-gate command', () => {
       mockFs.readFile.mockResolvedValue(JSON.stringify({}));
 
       const result = await checkCoverage('/project', 80);
-      expect(result).toBe(false);
+
+      expect(result).toEqual({ kind: 'skip', reason: '覆盖率不足: 0% < 80%' });
     });
   });
 
@@ -196,17 +195,15 @@ describe('passes-gate command', () => {
     it('应该检测 pytest 项目', async () => {
       // package.json 不存在
       mockFs.readFile.mockRejectedValue(new Error('no file'));
-      // pytest.ini 存在
-      mockFs.access
-        .mockResolvedValueOnce(undefined) // pytest.ini
-        .mockRejectedValueOnce(new Error('no file')); // go.mod
+      // pyproject.toml 存在（Python 标记任一命中即 pytest）
+      mockFs.access.mockResolvedValueOnce(undefined); // pyproject.toml
 
       const mockRunTests = jest.fn().mockResolvedValue({
         passed: true, passedTests: 5, failedTests: 0, totalTests: 5, duration: 500, failures: [],
       });
       (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
 
-      await runPassesGate({});
+      await runPassesGate({}, io);
       expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'pytest' }));
     });
 
@@ -215,6 +212,7 @@ describe('passes-gate command', () => {
       // Reset access mock to avoid leaking from previous tests
       mockFs.access.mockReset();
       mockFs.access
+        .mockRejectedValueOnce(new Error('no file')) // pyproject.toml
         .mockRejectedValueOnce(new Error('no file')) // pytest.ini
         .mockResolvedValueOnce(undefined); // go.mod
 
@@ -223,7 +221,7 @@ describe('passes-gate command', () => {
       });
       (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
 
-      await runPassesGate({});
+      await runPassesGate({}, io);
       expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'go test ./...' }));
     });
 
@@ -237,7 +235,7 @@ describe('passes-gate command', () => {
       });
       (MockPassesGate as any).mockImplementation(() => ({ runTests: mockRunTests }));
 
-      await runPassesGate({});
+      await runPassesGate({}, io);
       expect(MockPassesGate).toHaveBeenCalledWith(expect.objectContaining({ testCommand: 'npm run test:ci' }));
     });
 
@@ -249,8 +247,8 @@ describe('passes-gate command', () => {
       mockFs.access.mockReset();
       mockFs.access.mockRejectedValue(new Error('no file'));
 
-      await runPassesGate({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未检测到测试命令'));
+      await runPassesGate({}, io);
+      expect(io.outText()).toContain('未检测到测试命令');
     });
   });
 });

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

@@ -3,6 +3,7 @@
  */
 
 import { performance } from '../performance';
+import { captureIO, type CapturingIO } from '../../command-contract';
 import { PerformanceGate } from '../../../gates/performance';
 
 jest.mock('../../../gates/performance', () => ({
@@ -21,20 +22,12 @@ jest.mock('chalk', () => ({
 const MockGate = PerformanceGate as jest.MockedClass<typeof PerformanceGate>;
 
 describe('performance 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();
   });
 
   it('should print success when check passes', async () => {
@@ -47,10 +40,10 @@ describe('performance command', () => {
     });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({});
+    const result = await performance({}, 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 () => {
@@ -61,27 +54,33 @@ describe('performance command', () => {
     });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({});
+    const result = await performance({}, io);
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('性能门控检查失败'));
-    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(io.outText()).toContain('性能门控检查失败');
+    expect(result).toEqual({
+      kind: 'fail',
+      reason: 'performance gate denied: threshold exceeded',
+    });
   });
 
   it('should handle errors and exit 1', async () => {
     const mockCheck = jest.fn().mockRejectedValue(new Error('gate error'));
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({});
+    const result = await performance({}, io);
 
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('性能门控检查出错'));
-    expect(exitSpy).toHaveBeenCalledWith(1);
+    expect(io.outText()).toContain('性能门控检查出错');
+    expect(result).toEqual({
+      kind: 'fail',
+      reason: 'performance gate error: gate error',
+    });
   });
 
   it('should convert bundleThreshold from KB to bytes', async () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({ bundleThreshold: 500 });
+    await performance({ bundleThreshold: 500 }, io);
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -94,7 +93,7 @@ describe('performance command', () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({ benchmarkTimeout: 30 });
+    await performance({ benchmarkTimeout: 30 }, io);
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({ benchmarkTimeout: 30000 }),
@@ -105,7 +104,7 @@ describe('performance command', () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
-    await performance({ coverage: true, coverageThreshold: 90 });
+    await performance({ coverage: true, coverageThreshold: 90 }, io);
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({