@dommaker/harness 0.13.0 → 0.13.2

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

@@ -0,0 +1,343 @@
+/**
+ * flow 命令测试
+ */
+
+import { flow } from '../flow';
+import * as fs from 'fs';
+import * as readline from 'readline';
+import { TraceCollector } from '../../../monitoring/traces';
+import { TraceAnalyzer } from '../../../monitoring/trace-analyzer';
+import { ConstraintDoctor } from '../../../monitoring/constraint-doctor';
+import { ConstraintEvolver } from '../../../monitoring/constraint-evolver';
+
+// Mock fs
+jest.mock('fs', () => ({
+  existsSync: jest.fn().mockReturnValue(false),
+  readFileSync: jest.fn().mockReturnValue(''),
+  mkdirSync: jest.fn(),
+  writeFileSync: jest.fn(),
+}));
+
+// Mock readline
+jest.mock('readline', () => ({
+  createInterface: jest.fn().mockReturnValue({
+    question: jest.fn(),
+    close: jest.fn(),
+  }),
+}));
+
+// Mock monitoring modules
+jest.mock('../../../monitoring/traces', () => ({
+  TraceCollector: jest.fn(),
+}));
+
+jest.mock('../../../monitoring/trace-analyzer', () => ({
+  TraceAnalyzer: jest.fn(),
+}));
+
+jest.mock('../../../monitoring/constraint-doctor', () => ({
+  ConstraintDoctor: jest.fn(),
+}));
+
+jest.mock('../../../monitoring/constraint-evolver', () => ({
+  ConstraintEvolver: jest.fn(),
+}));
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  blue: jest.fn((str: string) => str),
+  yellow: jest.fn((str: string) => str),
+  green: jest.fn((str: string) => str),
+  gray: jest.fn((str: string) => str),
+  red: jest.fn((str: string) => str),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+const MockTraceCollector = TraceCollector as jest.MockedClass<typeof TraceCollector>;
+const MockTraceAnalyzer = TraceAnalyzer as jest.MockedClass<typeof TraceAnalyzer>;
+const MockConstraintDoctor = ConstraintDoctor as jest.MockedClass<typeof ConstraintDoctor>;
+const MockConstraintEvolver = ConstraintEvolver as jest.MockedClass<typeof ConstraintEvolver>;
+
+describe('flow command', () => {
+  let consoleSpy: jest.SpyInstance;
+  let mockRl: { question: jest.Mock; close: jest.Mock };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    process.exitCode = 0;
+
+    mockRl = {
+      question: jest.fn((q: string, cb: (a: string) => void) => cb('y')),
+      close: jest.fn(),
+    };
+    (readline.createInterface as jest.Mock).mockReturnValue(mockRl);
+    
+    // Reset fs mocks
+    mockFs.existsSync.mockReturnValue(false);
+    mockFs.readFileSync.mockReturnValue('');
+    mockFs.mkdirSync.mockReturnValue('');
+    mockFs.writeFileSync.mockReturnValue(undefined as any);
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    process.exitCode = 0;
+  });
+
+  describe('flow', () => {
+    it('应该跳过无 trace 记录情况', async () => {
+      mockFs.existsSync.mockReturnValue(false);
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('暂无 Trace'));
+    });
+
+    it('应该跳过无异常情况', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue('{}');
+
+      const mockCollector = {
+        read: jest.fn().mockReturnValue([]),
+      };
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => mockCollector);
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未发现异常'));
+    });
+
+    it('应该运行完整流程', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockCollector = {
+        read: jest.fn().mockReturnValue([]),
+      };
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([
+          { constraintId: 'test', level: 'iron_law', passRate: 0.3 },
+        ]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => mockCollector);
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      const mockDoctor = {
+        diagnose: jest.fn().mockResolvedValue({
+          anomalyId: 'test-anomaly',
+          constraintId: 'test',
+          rootCause: { primary: 'test' },
+          impact: { severity: 'high' },
+        }),
+      };
+      (MockConstraintDoctor as any).mockImplementation(() => mockDoctor);
+
+      const mockEvolver = {
+        propose: jest.fn().mockResolvedValue({
+          constraintId: 'test',
+          type: 'adjust_threshold',
+          risk: { level: 'low' },
+        }),
+      };
+      (MockConstraintEvolver as any).mockImplementation(() => mockEvolver);
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('流程完成'));
+    });
+
+    it('应该支持从诊断步骤开始', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockCollector = {
+        read: jest.fn().mockReturnValue([]),
+      };
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => mockCollector);
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      await flow({ from: 'diagnose' });
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+
+    it('应该自动应用低风险提案', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockCollector = {
+        read: jest.fn().mockReturnValue([]),
+      };
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([
+          { constraintId: 'test', level: 'iron_law', passRate: 0.3 },
+        ]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => mockCollector);
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      const mockDoctor = {
+        diagnose: jest.fn().mockResolvedValue({
+          anomalyId: 'test-anomaly',
+          constraintId: 'test',
+          rootCause: { primary: 'test' },
+          impact: { severity: 'high' },
+        }),
+      };
+      (MockConstraintDoctor as any).mockImplementation(() => mockDoctor);
+
+      const mockEvolver = {
+        propose: jest.fn().mockResolvedValue({
+          constraintId: 'test',
+          type: 'adjust_threshold',
+          risk: { level: 'low' },
+        }),
+      };
+      (MockConstraintEvolver as any).mockImplementation(() => mockEvolver);
+
+      mockRl.question
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'))
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'));
+
+      await flow({ autoApply: true });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('自动应用'));
+    });
+
+    it('应该取消当用户在步骤1输入 n', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => ({}));
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      mockRl.question.mockImplementationOnce((q: string, cb: (a: string) => void) => cb('n'));
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已取消'));
+    });
+
+    it('应该跳过提案当无提案生成', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => ({}));
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      const mockDoctor = {
+        diagnose: jest.fn().mockResolvedValue({
+          constraintId: 'test',
+          rootCause: { primary: 'test' },
+          impact: { severity: 'high' },
+        }),
+      };
+      (MockConstraintDoctor as any).mockImplementation(() => mockDoctor);
+
+      const mockEvolver = {
+        propose: jest.fn().mockResolvedValue(null),
+      };
+      (MockConstraintEvolver as any).mockImplementation(() => mockEvolver);
+
+      mockRl.question
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'))
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'));
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('无需优化'));
+    });
+
+    it('应该处理诊断失败', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => ({}));
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      const mockDoctor = {
+        diagnose: jest.fn().mockRejectedValue(new Error('diagnosis failed')),
+      };
+      (MockConstraintDoctor as any).mockImplementation(() => mockDoctor);
+
+      const mockEvolver = {
+        propose: jest.fn().mockResolvedValue(null),
+      };
+      (MockConstraintEvolver as any).mockImplementation(() => mockEvolver);
+
+      mockRl.question
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'))
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'));
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('诊断失败'));
+    });
+
+    it('应该跳过提案当用户输入 n', async () => {
+      mockFs.existsSync.mockReturnValue(true);
+      mockFs.readFileSync.mockReturnValue(JSON.stringify({ constraintId: 'test' }));
+
+      const mockAnalyzer = {
+        summarize: jest.fn().mockReturnValue([]),
+        detectAnomalies: jest.fn().mockReturnValue([
+          { constraintId: 'test', type: 'high_failure_rate' },
+        ]),
+      };
+      (MockTraceCollector as any).mockImplementation(() => ({}));
+      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyzer);
+
+      const mockDoctor = {
+        diagnose: jest.fn().mockResolvedValue({
+          constraintId: 'test',
+          rootCause: { primary: 'test' },
+          impact: { severity: 'high' },
+        }),
+      };
+      (MockConstraintDoctor as any).mockImplementation(() => mockDoctor);
+
+      const mockEvolver = {
+        propose: jest.fn().mockResolvedValue({
+          constraintId: 'test',
+          type: 'adjust_threshold',
+          risk: { level: 'medium' },
+        }),
+      };
+      (MockConstraintEvolver as any).mockImplementation(() => mockEvolver);
+
+      mockRl.question
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'))
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('y'))
+        .mockImplementationOnce((q: string, cb: (a: string) => void) => cb('n'));
+
+      await flow({});
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('跳过提案'));
+    });
+  });
+});

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

@@ -0,0 +1,306 @@
+/**
+ * init 命令测试
+ */
+
+import { init } from '../init';
+import * as fs from 'fs/promises';
+
+// Mock fs/promises
+const mockReaddir = jest.fn().mockResolvedValue([]);
+const existingFiles = new Set<string>();
+
+// Mock fs (sync) for detectSourceRoots and setupClaudeMdConstraints
+const mockExistsSync = jest.fn().mockReturnValue(false);
+const mockReaddirSync = jest.fn().mockReturnValue([]);
+
+jest.mock('fs', () => ({
+  existsSync: (...args: any[]) => mockExistsSync(...args),
+  readdirSync: (...args: any[]) => mockReaddirSync(...args),
+  statSync: jest.fn(),
+  readFileSync: jest.fn().mockReturnValue('{"version": "1.0.0"}'),
+}));
+
+jest.mock('fs/promises', () => ({
+  mkdir: jest.fn(),
+  writeFile: jest.fn(),
+  readFile: jest.fn().mockRejectedValue(new Error('ENOENT')),
+  access: jest.fn((path: string) => {
+    if (existingFiles.has(path)) return Promise.resolve(undefined);
+    return Promise.reject(new Error(`ENOENT: ${path}`));
+  }),
+  chmod: jest.fn(),
+  readdir: (...args: any[]) => mockReaddir(...args),
+}));
+
+// Mock js-yaml
+jest.mock('js-yaml', () => ({
+  dump: jest.fn().mockReturnValue('yaml content'),
+  load: jest.fn(),
+}));
+
+// Mock chalk
+jest.mock('chalk', () => ({
+  blue: jest.fn((str: string) => str),
+  yellow: jest.fn((str: string) => str),
+  green: jest.fn((str: string) => str),
+  gray: jest.fn((str: string) => str),
+  red: jest.fn((str: string) => str),
+  cyan: jest.fn((str: string) => str),
+  bold: jest.fn((str: string) => str),
+}));
+
+// Mock validate module
+jest.mock('../validate', () => ({
+  createExampleCheckpoint: jest.fn(),
+  createExampleResolutions: jest.fn(),
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+
+// Use explicit projectPath to avoid CI path mismatch
+const PROJECT = '/test/project';
+
+describe('init command', () => {
+  let consoleSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    existingFiles.clear();
+    mockExistsSync.mockReturnValue(false);
+    mockReaddirSync.mockReturnValue([]);
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+  });
+
+  describe('init', () => {
+    it('应该创建配置目录', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(mockFs.mkdir).toHaveBeenCalled();
+    });
+
+    it('应该使用 strict 预设', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'strict', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('strict'));
+    });
+
+    it('应该使用 relaxed 预设', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'relaxed', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('relaxed'));
+    });
+
+    it('应该支持自定义项目路径', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', projectPath: '/custom/path' });
+      expect(mockFs.mkdir).toHaveBeenCalled();
+    });
+
+    it('应该输出代码片段模式', async () => {
+      await init({ preset: 'standard', printSnippets: true });
+      expect(consoleSpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('Git hooks', () => {
+    it('应该跳过 Git hooks 当无 .git 目录', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('未检测到 Git 仓库'));
+    });
+
+    it('应该提示手动添加当 pre-commit 已存在', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+      existingFiles.add(`${PROJECT}/.git/hooks/pre-commit`);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('pre-commit 已存在'));
+    });
+
+    it('应该创建 pre-commit hook', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.git`);
+      existingFiles.add(`${PROJECT}/.git/hooks`);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已创建 .git/hooks/pre-commit'));
+    });
+  });
+
+  describe('GitHub Actions', () => {
+    it('应该提示当已有 CI 配置', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      mockReaddir.mockResolvedValue(['ci.yml']);
+      existingFiles.add(`${PROJECT}/.github/workflows`);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('已存在的 CI 配置'));
+    });
+  });
+
+  describe('CAPABILITIES.md', () => {
+    it('init 不应创建 CAPABILITIES.md（由 sync-docs 管理）', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      const writes = mockFs.writeFile.mock.calls.map((c: unknown[]) => String(c[0]));
+      expect(writes.every((w: string) => !w.includes('CAPABILITIES.md'))).toBe(true);
+    });
+  });
+
+  describe('custom-constraints', () => {
+    it('应该跳过创建当已存在', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.harness/custom-constraints.yml`);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('custom-constraints.yml 已存在'));
+    });
+  });
+
+  describe('governance', () => {
+    it('应该在配置中包含 governance 段', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('治理级别: standard'));
+    });
+
+    it('应该创建 CHANGELOG.md', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const changelogCall = writeCalls.find((c: any[]) => String(c[0]).includes('CHANGELOG.md'));
+      expect(changelogCall).toBeDefined();
+      expect(changelogCall![1]).toContain('Changelog');
+    });
+
+    it('应该跳过 CHANGELOG.md 当已存在', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/CHANGELOG.md`);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('CHANGELOG.md 已存在'));
+    });
+
+    it('应该为 standard 治理创建 src/CONTEXT.md', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/src`);
+
+      mockExistsSync.mockImplementation((path: string) => path === `${PROJECT}/src`);
+      mockReaddirSync.mockImplementation((dir: string) => {
+        if (dir === `${PROJECT}/src`) {
+          return [{ name: 'index.ts', isFile: () => true, isDirectory: () => false }];
+        }
+        return [];
+      });
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const contextCall = writeCalls.find((c: any[]) => String(c[0]).includes('CONTEXT.md'));
+      expect(contextCall).toBeDefined();
+      expect(contextCall![1]).toContain('职责');
+    });
+
+    it('应该跳过 CONTEXT.md 当目录不存在', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const contextCall = writeCalls.find((c: any[]) => String(c[0]).includes('CONTEXT.md'));
+      expect(contextCall).toBeUndefined();
+    });
+
+    it('minimal 治理不应创建 CONTEXT.md', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'minimal', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const contextCall = writeCalls.find((c: any[]) => String(c[0]).includes('CONTEXT.md'));
+      expect(contextCall).toBeUndefined();
+    });
+
+    it('应该创建治理 CI workflow', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const workflowCall = writeCalls.find((c: any[]) => String(c[0]).includes('harness-governance.yml'));
+      expect(workflowCall).toBeDefined();
+      expect(workflowCall![1]).toContain('Harness Governance');
+      expect(workflowCall![1]).toContain('harness check');
+    });
+
+    it('应该跳过治理 CI workflow 当已存在', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+      existingFiles.add(`${PROJECT}/.github/workflows/harness-governance.yml`);
+
+      await init({ preset: 'standard', governance: 'standard', projectPath: PROJECT });
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('harness-governance.yml 已存在'));
+    });
+
+    it('strict 治理应在 CI 中包含 docs check', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'strict', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const workflowCall = writeCalls.find((c: any[]) => String(c[0]).includes('harness-governance.yml'));
+      expect(workflowCall![1]).toContain('sync-docs');
+    });
+
+    it('minimal 治理不应在 CI 中包含 docs check', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', governance: 'minimal', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const workflowCall = writeCalls.find((c: any[]) => String(c[0]).includes('harness-governance.yml'));
+      expect(workflowCall![1]).not.toContain('sync-docs');
+    });
+
+    it('无 governance 选项时不应创建治理文件', async () => {
+      mockFs.mkdir.mockResolvedValue(undefined);
+      mockFs.writeFile.mockResolvedValue(undefined);
+
+      await init({ preset: 'standard', projectPath: PROJECT });
+      const writeCalls = mockFs.writeFile.mock.calls;
+      const changelogCall = writeCalls.find((c: any[]) => String(c[0]).includes('CHANGELOG.md'));
+      const contextCall = writeCalls.find((c: any[]) => String(c[0]).includes('CONTEXT.md'));
+      const workflowCall = writeCalls.find((c: any[]) => String(c[0]).includes('harness-governance.yml'));
+      expect(changelogCall).toBeUndefined();
+      expect(contextCall).toBeUndefined();
+      expect(workflowCall).toBeUndefined();
+    });
+  });
+});