@dommaker/harness 1.3.0 → 1.4.0

package/src/core/constraints/checkers/__tests__/capability-sync.test.ts

@@ -0,0 +1,214 @@
+/**
+ * capability_sync 检查器旁测（ADR-0009 / 架构评审候选4）
+ *
+ * 测试面 = ConstraintCheck.evaluate(env)：证据经 EvidenceProviders 注入，
+ * 不再绕 engine facade（checker.check）与真实 git staging。
+ * 自 checker-extra.test.ts 迁入并改写驱动方式；断言语义逐条保持。
+ * 项目根由 src/test-setup/project-fixture 声明式构造（回收仍走 mkdtemp-cleanup）。
+ */
+
+import { describe, it, expect, jest } from '@jest/globals';
+import { capabilitySync } from '../capability-sync';
+import { buildCheckEnv, type CheckEnv } from '../types';
+import { collectSourceFiles } from '../../capabilities-reconcile';
+import { createProjectFixture } from '../../../../test-setup/project-fixture';
+import type { ConstraintContext } from '../../../../types/constraint';
+
+const TABLE_HEAD = '| 模块 | 文件 | 说明 |\n|------|------|------|\n';
+
+function setupDir(
+  name: string,
+  capContent: string,
+  files: string[] = [],
+  mode?: 'file' | 'module'
+): string {
+  return createProjectFixture({
+    name: `cap-sync-${name}`,
+    config: mode ? `governance:\n  capabilities:\n    mode: ${mode}\n` : undefined,
+    files: {
+      'CAPABILITIES.md': capContent,
+      ...Object.fromEntries(files.map(f => [f, 'export const x = 1;'])),
+    },
+  });
+}
+
+/** stub staged 清单；srcScan 缺省走真实 fs（与被检文件一致），传 scan 则按根覆写 */
+function makeEnv(
+  projectPath: string,
+  staged: string[],
+  scan?: Record<string, string[]>
+): CheckEnv {
+  const context: ConstraintContext = { operation: 'commit', projectPath };
+  return buildCheckEnv(context, {
+    stagedDiff: async () => '',
+    stagedDiffNames: async () => staged.join('\n'),
+    srcScan: (root: string) =>
+      scan ? scan[root] ?? [] : collectSourceFiles(projectPath, [root]),
+  });
+}
+
+describe('capability_sync — skip 与文档格式门槛', () => {
+  it('无 CAPABILITIES.md → skip（ADR-0001 存在性探测，有无变更都一样）', async () => {
+    const dir = createProjectFixture({ name: 'cap-sync-none' });
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe('skip');
+    expect(await capabilitySync.evaluate(makeEnv(dir, ['src/foo.ts']))).toBe('skip');
+  });
+
+  it('散文文档（无表格）+ 有变更 → 放行（历史语义）', async () => {
+    const dir = setupDir('prose', '# Capabilities\n\n- Feature: test', ['feature.ts']);
+    expect(await capabilitySync.evaluate(makeEnv(dir, ['feature.ts']))).toBe(true);
+  });
+
+  it('清单格式（计数行）→ 放行，计数由 sync-docs 维护', async () => {
+    const dir = setupDir('listing', '# Capabilities\n\n## CLI Commands (25)\ncheck, validate\n');
+    expect(await capabilitySync.evaluate(makeEnv(dir, ['src/foo.ts']))).toBe(true);
+  });
+
+  it('有表格但零条目 + 有变更 → 不得放行', async () => {
+    const dir = setupDir('empty-table', `# Capabilities\n\n${TABLE_HEAD}`);
+    expect(await capabilitySync.evaluate(makeEnv(dir, ['src/foo.ts']))).toBe(false);
+  });
+
+  it('有表格但零条目 + 源码有文件 → step2 不得放行', async () => {
+    const dir = setupDir('empty-table-scan', `# Capabilities\n\n${TABLE_HEAD}`, ['src/foo.ts']);
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(false);
+  });
+});
+
+describe('capability_sync — step1 增量覆盖', () => {
+  const run = (dir: string, staged: string[]) =>
+    capabilitySync.evaluate(makeEnv(dir, staged, {}));
+
+  it('变更文件未被登记 → 失败', async () => {
+    const dir = setupDir('step1-uncovered', `# C\n\n${TABLE_HEAD}| 旧 | old/module.ts | 旧 |\n`);
+    expect(await run(dir, ['new-module.ts'])).toBe(false);
+  });
+
+  it('变更文件按登记路径覆盖 → 通过', async () => {
+    const dir = setupDir('step1-covered', `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`);
+    expect(await run(dir, ['src/foo.ts'])).toBe(true);
+  });
+
+  it('每个变更文件都必须被覆盖（every 而非 some）', async () => {
+    const dir = setupDir('step1-every', `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`);
+    expect(await run(dir, ['src/foo.ts', 'scripts/bar.ts'])).toBe(false);
+  });
+
+  it('后缀碰撞不覆盖：xfoo.ts 不被 foo.ts 条目覆盖', async () => {
+    const dir = setupDir('step1-endswith', `# C\n\n${TABLE_HEAD}| foo | foo.ts | foo |\n`);
+    expect(await run(dir, ['web/xfoo.ts'])).toBe(false);
+  });
+
+  it('子串误配不覆盖：docs/src/foo.tsx 不被 src/foo.ts 条目覆盖', async () => {
+    const dir = setupDir('step1-includes', `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`);
+    expect(await run(dir, ['docs/src/foo.tsx'])).toBe(false);
+  });
+
+  it('basename 条目按路径边界后缀覆盖（src/foo.ts 被 foo.ts 覆盖）', async () => {
+    const dir = setupDir('step1-suffix-ok', `# C\n\n${TABLE_HEAD}| foo | foo.ts | foo |\n`);
+    expect(await run(dir, ['src/foo.ts'])).toBe(true);
+  });
+
+  it('测试文件与非代码变更不参与 step1', async () => {
+    const dir = setupDir('step1-noncode', `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`);
+    expect(
+      await run(dir, ['src/__tests__/foo.test.ts', 'docs/readme.md', 'package.json'])
+    ).toBe(true);
+  });
+});
+
+describe('capability_sync — step2 全量覆盖（file 模式）', () => {
+  it('全部源文件已登记 → 通过', async () => {
+    const dir = setupDir(
+      'step2-ok',
+      `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`,
+      ['src/foo.ts']
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(true);
+  });
+
+  it('有未登记源文件 → 失败', async () => {
+    const dir = setupDir(
+      'step2-missing',
+      `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`,
+      ['src/foo.ts', 'src/unlisted.ts']
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(false);
+  });
+
+  it('basename 条目同样按边界后缀覆盖 step2（step1/step2 语义一致）', async () => {
+    const dir = setupDir(
+      'step2-basename',
+      `# C\n\n${TABLE_HEAD}| foo | foo.ts | foo |\n`,
+      ['src/foo.ts']
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(true);
+  });
+
+  it('不同路径同后缀文件不被误覆盖（lib/foo.ts 不覆盖 src/foo.ts）', async () => {
+    const dir = setupDir(
+      'step2-boundary',
+      `# C\n\n${TABLE_HEAD}| foo | lib/foo.ts | foo |\n`,
+      ['src/foo.ts']
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(false);
+  });
+});
+
+describe('capability_sync — module 模式（未覆盖聚合为目录形状）', () => {
+  it('目录条目覆盖源文件 → 通过', async () => {
+    const dir = setupDir(
+      'mod-covered',
+      `# C\n\n${TABLE_HEAD}| 核心 | src/core/ | 核心 |\n`,
+      ['src/core/foo.ts', 'src/core/bar.ts'],
+      'module'
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(true);
+  });
+
+  it('文件条目精确匹配也算覆盖', async () => {
+    const dir = setupDir(
+      'mod-file-entry',
+      `# C\n\n${TABLE_HEAD}| foo | src/core/foo.ts | foo |\n`,
+      ['src/core/foo.ts'],
+      'module'
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(true);
+  });
+
+  it('新目录未登记 → 失败', async () => {
+    const dir = setupDir(
+      'mod-uncovered',
+      `# C\n\n${TABLE_HEAD}| 核心 | src/core/ | 核心 |\n`,
+      ['src/core/foo.ts', 'src/newdir/bar.ts'],
+      'module'
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(false);
+  });
+
+  it('module 模式文件条目按边界后缀覆盖（step1/step2 同规则）', async () => {
+    const dir = setupDir(
+      'mod-suffix',
+      `# C\n\n${TABLE_HEAD}| foo | foo.ts | foo |\n`,
+      ['src/foo.ts'],
+      'module'
+    );
+    expect(await capabilitySync.evaluate(makeEnv(dir, []))).toBe(true);
+  });
+});
+
+describe('capability_sync — fail-open 可观测', () => {
+  it('证据读取异常时放行但输出 warn', async () => {
+    const dir = setupDir('failopen', `# C\n\n${TABLE_HEAD}| foo | src/foo.ts | foo |\n`);
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    const env: CheckEnv = {
+      ...makeEnv(dir, []),
+      stagedDiffNames: async () => {
+        throw new Error('git boom');
+      },
+    };
+    expect(await capabilitySync.evaluate(env)).toBe(true);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+});

package/src/core/constraints/checkers/__tests__/context-doc-sync.test.ts

@@ -0,0 +1,77 @@
+/**
+ * context_doc_sync 检查器旁测（架构评审候选4，ADR-0009 同模式）
+ *
+ * 测试面 = ConstraintCheck.evaluate(env)：项目目录为真实 fs 临时目录，
+ * 证据经 buildCheckEnv 注入（本检查器只用 projectPath，证据走 'none'）。
+ * 自 checker-extra.test.ts 迁入并告别 engine facade；三态收紧——
+ * facade 下 skip 表现为 satisfied:true，旁测直接钉 'skip'。
+ * 项目根由 src/test-setup/project-fixture 声明式构造（回收仍走 mkdtemp-cleanup）。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import { contextDocSync } from '../context-doc-sync';
+import { buildCheckEnv } from '../types';
+import { createProjectFixture } from '../../../../test-setup/project-fixture';
+import type { ConstraintContext } from '../../../../types/constraint';
+
+function setupDir(
+  name: string,
+  configYml: string | null,
+  contextMdDirs: string[] = []
+): string {
+  return createProjectFixture({
+    name: `ctx-doc-sync-${name}`,
+    config: configYml ?? undefined,
+    files: Object.fromEntries(contextMdDirs.map(d => [`${d}/CONTEXT.md`, `# ${d}\n`])),
+  });
+}
+
+function evaluate(dir: string) {
+  const context: ConstraintContext = { operation: 'module_modification', projectPath: dir };
+  return contextDocSync.evaluate(buildCheckEnv(context, 'none'));
+}
+
+const CTX_FILES = (enabled: boolean, dirs?: string[]) =>
+  `governance:\n  context_files:\n    enabled: ${enabled}\n` +
+  (dirs ? `    required_dirs: [${dirs.map(d => `'${d}'`).join(', ')}]\n` : '');
+
+describe('context_doc_sync — skip 门槛（ADR-0001 存在性探测）', () => {
+  it('无 .harness/config.yml → skip', async () => {
+    expect(await evaluate(setupDir('no-config', null))).toBe('skip');
+  });
+
+  it('配置无 governance.context_files → skip', async () => {
+    expect(await evaluate(setupDir('no-section', 'preset: standard\n'))).toBe('skip');
+  });
+
+  it('enabled: false → skip（facade 旧断言 satisfied:true 的真实语义）', async () => {
+    expect(await evaluate(setupDir('disabled', CTX_FILES(false, ['src'])))).toBe('skip');
+  });
+
+  it('enabled 但 required_dirs 缺失/非数组/空 → skip', async () => {
+    expect(await evaluate(setupDir('no-dirs', CTX_FILES(true)))).toBe('skip');
+    expect(await evaluate(setupDir('empty-dirs', CTX_FILES(true, [])))).toBe('skip');
+    expect(
+      await evaluate(
+        setupDir('bad-dirs', 'governance:\n  context_files:\n    enabled: true\n    required_dirs: src\n')
+      )
+    ).toBe('skip');
+  });
+});
+
+describe('context_doc_sync — 判定', () => {
+  it('required_dirs 全部有 CONTEXT.md → pass', async () => {
+    const dir = setupDir('all-present', CTX_FILES(true, ['src', 'bin']), ['src', 'bin']);
+    expect(await evaluate(dir)).toBe(true);
+  });
+
+  it('任一目录缺 CONTEXT.md → fail', async () => {
+    const dir = setupDir('one-missing', CTX_FILES(true, ['src', 'bin']), ['src']);
+    expect(await evaluate(dir)).toBe(false);
+  });
+
+  it('配置解析失败 → skip（不炸不报）', async () => {
+    const dir = setupDir('bad-yaml', 'governance: [\n  broken: {{\n');
+    expect(await evaluate(dir)).toBe('skip');
+  });
+});

package/src/core/constraints/checkers/__tests__/docs-freshness.test.ts

@@ -0,0 +1,117 @@
+/**
+ * docs_freshness 检查器旁测（ADR-0009 / 架构评审候选4）
+ *
+ * 测试面 = ConstraintCheck.evaluate(env)。幽灵判定走 capabilities-reconcile：
+ * 文件与目录条目都查（口径从严）；无约定文件 → skip。
+ * 项目根由 src/test-setup/project-fixture 声明式构造（回收仍走 mkdtemp-cleanup）。
+ */
+
+import { describe, it, expect, jest } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import { docsFreshness } from '../docs-freshness';
+import { buildCheckEnv } from '../types';
+import { collectSourceFiles } from '../../capabilities-reconcile';
+import { createProjectFixture } from '../../../../test-setup/project-fixture';
+import type { ConstraintContext } from '../../../../types/constraint';
+
+const TABLE_HEAD = '| 模块 | 文件 | 说明 |\n|------|------|------|\n';
+
+function setupProject(name: string, files: string[]): string {
+  return createProjectFixture({
+    name: `docs-fresh-${name}`,
+    files: Object.fromEntries(files.map(f => [f, 'export const x = 1;'])),
+  });
+}
+
+function makeEnv(projectPath: string): ReturnType<typeof buildCheckEnv> {
+  const context: ConstraintContext = { operation: 'file_modification', projectPath };
+  return buildCheckEnv(context, {
+    stagedDiff: async () => '',
+    stagedDiffNames: async () => '',
+    srcScan: (root: string) => collectSourceFiles(projectPath, [root]),
+  });
+}
+
+function writeCap(dir: string, body: string): void {
+  fs.writeFileSync(path.join(dir, 'CAPABILITIES.md'), `# Capabilities\n\n${body}`);
+}
+
+describe('docs_freshness — 存在性探测（ADR-0001）', () => {
+  it('无 CAPABILITIES.md/CHANGELOG/配置 → skip，不计 pass/fail', async () => {
+    const dir = setupProject('none', ['src/module.ts']);
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe('skip');
+  });
+});
+
+describe('docs_freshness — 幽灵判定（文档→代码方向）', () => {
+  it('散文文档（无表格）→ 通过', async () => {
+    const dir = setupProject('no-table', []);
+    writeCap(dir, 'No table here.');
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(true);
+  });
+
+  it('登记的文件全部存在 → 通过', async () => {
+    const dir = setupProject('valid', ['src/old.ts', 'src/new.ts']);
+    writeCap(
+      dir,
+      `${TABLE_HEAD}| old | src/old.ts | old |\n| new | src/new.ts | new |`
+    );
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(true);
+  });
+
+  it('登记的文件已删除 → 失败并点名条目', async () => {
+    const dir = setupProject('ghost-file', ['src/old.ts']);
+    writeCap(
+      dir,
+      `${TABLE_HEAD}| old | src/old.ts | old |\n| deleted | src/deleted.ts | deleted |`
+    );
+    const errSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(false);
+    expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('src/deleted.ts'));
+    errSpy.mockRestore();
+  });
+
+  it('登记的目录条目已消失 → 失败（ADR-0009 口径从严，文件+目录都查）', async () => {
+    const dir = setupProject('ghost-dir', ['src/core/foo.ts']);
+    writeCap(
+      dir,
+      `${TABLE_HEAD}| 核心 | src/core/ | 核心 |\n| 遗魂 | src/gone/ | 已删目录 |`
+    );
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(false);
+  });
+
+  it('登记的目录条目仍存在 → 通过', async () => {
+    const dir = setupProject('dir-alive', ['src/core/foo.ts']);
+    writeCap(dir, `${TABLE_HEAD}| 核心 | src/core/ | 核心 |`);
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(true);
+  });
+
+  it('basename 碰撞场景：全路径幽灵即使同名文件存活仍被报出（2026-08-08 事故回归）', async () => {
+    const dir = setupProject('collision', ['src/agents/routes.ts']);
+    writeCap(
+      dir,
+      `${TABLE_HEAD}| routes | src/agents/routes.ts | 活 |\n| 旧路由 | src/agent-configs/routes.ts | 已删 |`
+    );
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(false);
+  });
+});
+
+describe('docs_freshness — 内置 Runner 检查（changelog/context）', () => {
+  it('无 CHANGELOG 但有 CAPABILITIES.md 且条目健康 → 通过', async () => {
+    const dir = setupProject('runner-ok', ['src/module.ts']);
+    writeCap(dir, `${TABLE_HEAD}| module | src/module.ts | module |`);
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(true);
+  });
+
+  it('CHANGELOG 版本与 package.json 漂移 → 失败', async () => {
+    const dir = setupProject('ver-drift', ['src/module.ts']);
+    writeCap(dir, `${TABLE_HEAD}| module | src/module.ts | module |`);
+    fs.writeFileSync(
+      path.join(dir, 'package.json'),
+      JSON.stringify({ name: 'x', version: '2.0.0' })
+    );
+    fs.writeFileSync(path.join(dir, 'CHANGELOG.md'), '## [1.0.0] - 2026-01-01\n\n- old\n');
+    expect(await docsFreshness.evaluate(makeEnv(dir))).toBe(false);
+  });
+});

package/src/{__tests__ → core/constraints/checkers/__tests__}/governance-presence.test.ts

@@ -1,8 +1,11 @@
 /**
- * governance_presence checker 测试（studio #302，ADR 2026-08-21 落点模型）
+ * governance_presence 检查器旁测（studio #302，ADR 2026-08-21 落点模型）
  *
  * 在场守护：PRESERVE 只保「存在」不保「在场」——治理契约段被删除/掏空后
  * sync-docs 重新生成会静默丢失，本 checker 在 harness check 时校验在场性。
+ * 测试面 = evaluate(env)（架构评审候选4，自 src/__tests__/ 就近迁入）。
+ * 根由 src/test-setup/project-fixture 构造；本套件是 cwd 锚定用例，经
+ * parentDir: process.cwd() **显式** opt-out 保持原语义（harness#90 前置约束）。
  */
 
 import { describe, it, expect, beforeEach, afterEach, jest } from '@jest/globals';
@@ -12,8 +15,10 @@ import {
   governancePresence,
   hasGovernancePreserveBlock,
   hasClaudeGovernance,
-} from '../core/constraints/checkers/governance-presence';
-import type { CheckEnv } from '../core/constraints/checkers';
+} from '../governance-presence';
+import { detectInjectionDrift } from '../../injection-drift';
+import { createProjectFixture, writeProjectConfig } from '../../../../test-setup/project-fixture';
+import type { CheckEnv } from '../types';
 
 function makeEnv(projectPath: string): CheckEnv {
   return {
@@ -39,13 +44,13 @@ describe('governance_presence checker', () => {
   let tempDir: string;
   let errorSpy: jest.SpiedFunction<typeof console.error>;
 
-  const writeConfig = () => {
-    fs.mkdirSync(path.join(tempDir, '.harness'), { recursive: true });
-    fs.writeFileSync(path.join(tempDir, '.harness', 'config.yml'), 'preset: standard\n');
-  };
+  const writeConfig = () => writeProjectConfig(tempDir, 'preset: standard\n');
 
   beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(process.cwd(), 'temp-test-gov-presence-'));
+    tempDir = createProjectFixture({
+      name: 'temp-test-gov-presence',
+      parentDir: process.cwd(),
+    });
     errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
   });
 
@@ -70,6 +75,12 @@ describe('governance_presence checker', () => {
     expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
   });
 
+  it('旧模型豁免：CLAUDE.md 标题双空格变体也认（宽松谓词，fail-open）→ pass', async () => {
+    writeConfig();
+    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# CLAUDE.md\n\n##  Governance Rules\n\n条款\n');
+    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
+  });
+
   it('旧模型豁免：CLAUDE.md 有 HARNESS_CONSTRAINTS 标记 → pass', async () => {
     writeConfig();
     fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '<!-- HARNESS_CONSTRAINTS_START -->\nx\n');
@@ -107,7 +118,10 @@ describe('hasGovernancePreserveBlock / hasClaudeGovernance 判定函数', () =>
   let tempDir: string;
 
   beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(process.cwd(), 'temp-test-gov-helpers-'));
+    tempDir = createProjectFixture({
+      name: 'temp-test-gov-helpers',
+      parentDir: process.cwd(),
+    });
   });
 
   afterEach(() => {
@@ -126,4 +140,64 @@ describe('hasGovernancePreserveBlock / hasClaudeGovernance 判定函数', () =>
     fs.writeFileSync(p, `<!-- PRESERVE:governance -->\n条款一\n<!-- /PRESERVE:governance -->\n`);
     expect(hasGovernancePreserveBlock(p)).toBe(true);
   });
+
+  it('结束标记嵌在行中 = 畸形块 → false（显式收紧，#83：按契约丢失报警）', () => {
+    const p = path.join(tempDir, 'AGENTS.md');
+    fs.writeFileSync(
+      p,
+      '<!-- PRESERVE:governance -->\n条款一 <!-- /PRESERVE:governance --> 尾注\n'
+    );
+    expect(hasGovernancePreserveBlock(p)).toBe(false);
+  });
+});
+
+describe('governance_presence × detectInjectionDrift 同 fixture 一致性（#83）', () => {
+  let tempDir: string;
+
+  const writeConfig = () => writeProjectConfig(tempDir, 'preset: standard\n');
+
+  beforeEach(() => {
+    tempDir = createProjectFixture({
+      name: 'temp-test-gov-consistency',
+      parentDir: process.cwd(),
+    });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('双空格标题：presence 认在场（pass），drift 严格计数 0 不报重复——两层不再互相矛盾', async () => {
+    writeConfig();
+    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# CLAUDE.md\n\n##  Governance Rules\n\n条款\n');
+
+    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
+    const drift = detectInjectionDrift(tempDir);
+    expect(drift.notInjected).toBe(true);
+    expect(drift.duplicateHeading).toBe(false);
+    expect(drift.hasDrift).toBe(false);
+  });
+
+  it('精确拼写单标题：presence pass，drift 不报重复', async () => {
+    writeConfig();
+    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# CLAUDE.md\n\n## Governance Rules\n\n条款\n');
+
+    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
+    const drift = detectInjectionDrift(tempDir);
+    expect(drift.notInjected).toBe(true);
+    expect(drift.duplicateHeading).toBe(false);
+  });
+
+  it('精确拼写双标题：presence 认在场，drift 报重复章节（计数是 drift 的独立职责）', async () => {
+    writeConfig();
+    fs.writeFileSync(
+      path.join(tempDir, 'CLAUDE.md'),
+      '# CLAUDE.md\n\n## Governance Rules\n\n甲\n\n## Governance Rules\n\n乙\n'
+    );
+
+    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
+    const drift = detectInjectionDrift(tempDir);
+    expect(drift.notInjected).toBe(true);
+    expect(drift.duplicateHeading).toBe(true);
+  });
 });

package/src/core/constraints/checkers/__tests__/iron-flags.test.ts

@@ -0,0 +1,50 @@
+/**
+ * 铁律层 flag 检查旁测（架构评审候选4，ADR-0009 同模式）
+ *
+ * 三个 flag 铁律均为 contextEvidenceFlag 构造，真实 bug 面 = 读错上下文字段
+ * 与三态语义（undefined→skip / false→fail / true→pass）。直接喂不同字段组合
+ * 钉死映射，不再经 engine facade（旧测在 skip-semantics/checker.test 间接打）。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import {
+  noCompletionWithoutVerification,
+  incrementalProgress,
+  noImplementationWithoutRequirement,
+} from '../iron-flags';
+import { buildCheckEnv } from '../types';
+import type { ConstraintContext } from '../../../../types/constraint';
+
+const evaluate = (
+  check: { evaluate: (env: any) => unknown },
+  ctx: Partial<ConstraintContext>
+) => check.evaluate(buildCheckEnv({ ...ctx, operation: 'code_implementation' }, 'none'));
+
+describe('iron flags — 三态与字段映射', () => {
+  it('no_completion_without_verification → 读 hasVerificationEvidence', async () => {
+    expect(await evaluate(noCompletionWithoutVerification, {})).toBe('skip');
+    expect(await evaluate(noCompletionWithoutVerification, { hasVerificationEvidence: false })).toBe(false);
+    expect(await evaluate(noCompletionWithoutVerification, { hasVerificationEvidence: true })).toBe(true);
+    // 相邻字段不串台：hasTest 不能顶替
+    expect(await evaluate(noCompletionWithoutVerification, { hasTest: true })).toBe('skip');
+  });
+
+  it('incremental_progress → 读 hasSingleTask', async () => {
+    expect(await evaluate(incrementalProgress, {})).toBe('skip');
+    expect(await evaluate(incrementalProgress, { hasSingleTask: false })).toBe(false);
+    expect(await evaluate(incrementalProgress, { hasSingleTask: true })).toBe(true);
+  });
+
+  it('no_implementation_without_requirement → 读 hasRequirement', async () => {
+    expect(await evaluate(noImplementationWithoutRequirement, {})).toBe('skip');
+    expect(await evaluate(noImplementationWithoutRequirement, { hasRequirement: false })).toBe(false);
+    expect(await evaluate(noImplementationWithoutRequirement, { hasRequirement: true })).toBe(true);
+  });
+
+  it('三 flag 各自独立判定（组合上下文互不影响）', async () => {
+    const ctx: Partial<ConstraintContext> = { hasVerificationEvidence: true, hasSingleTask: false };
+    expect(await evaluate(noCompletionWithoutVerification, ctx)).toBe(true);
+    expect(await evaluate(incrementalProgress, ctx)).toBe(false);
+    expect(await evaluate(noImplementationWithoutRequirement, ctx)).toBe('skip');
+  });
+});

package/src/core/constraints/checkers/__tests__/no-bypass-checkpoint.test.ts

@@ -0,0 +1,76 @@
+/**
+ * no_bypass_checkpoint 检查器旁测（架构评审候选4，ADR-0009 同模式）
+ *
+ * 测试面 = ConstraintCheck.evaluate(env)：判定只读 env.context.changedFiles
+ * 的文件内容，无需 git staging（旧 facade 测用真实 git add 属多余 fixture）。
+ * 自 checker-extra.test.ts 迁入并补齐 BYPASS_PATTERNS 全表用例。
+ * 违规样例字符串一律拼接构造，避免本文件被该检查器自身命中。
+ * 项目根由 src/test-setup/project-fixture 声明式构造（回收仍走 mkdtemp-cleanup）。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import * as os from 'os';
+import * as path from 'path';
+import { noBypassCheckpoint } from '../no-bypass-checkpoint';
+import { buildCheckEnv } from '../types';
+import { createProjectFixture } from '../../../../test-setup/project-fixture';
+import type { ConstraintContext } from '../../../../types/constraint';
+
+/** 与 BYPASS_PATTERNS 对齐的违规样例（拼接构造，源文本不含完整模式串） */
+const VIOLATIONS: Array<[string, string]> = [
+  ['jest/vitest skip 调用', 'test.' + 'skip("skipped", () => {});'],
+  ['bypass 标志赋值', 'config.byp' + 'ass = true;'],
+  ['skip 选项', '{ run: { skip' + ': true } }'],
+  ['显式 bypass 注释', '# bypa' + 'ss checkpoint for perf'],
+  ['行注释 skip', 'code(); // ' + 'skip this for now'],
+];
+
+function writeTemp(name: string, content: string): string {
+  const root = createProjectFixture({
+    name: `no-bypass-${name}`,
+    files: { 'subject.ts': content },
+  });
+  return path.join(root, 'subject.ts');
+}
+
+function evaluate(changedFiles: string[]) {
+  const context: ConstraintContext = {
+    operation: 'code_implementation',
+    projectPath: process.cwd(),
+    changedFiles,
+  };
+  return noBypassCheckpoint.evaluate(buildCheckEnv(context, 'none'));
+}
+
+describe('no_bypass_checkpoint', () => {
+  it('无变更文件 → pass（默认放行）', async () => {
+    expect(await evaluate([])).toBe(true);
+  });
+
+  for (const [label, content] of VIOLATIONS) {
+    it(`命中 bypass 模式（${label}）→ fail`, async () => {
+      expect(await evaluate([writeTemp('hit', content)])).toBe(false);
+    });
+  }
+
+  it('干净测试文件 → pass（旧 facade 对照用例）', async () => {
+    expect(
+      await evaluate([writeTemp('clean', 'test("clean", () => { expect(1).toBe(1); });')])
+    ).toBe(true);
+  });
+
+  it('变更文件已删除（不在 fs）→ 跳过该文件继续', async () => {
+    expect(await evaluate([path.join(os.tmpdir(), 'no-bypass-gone', 'ghost.ts')])).toBe(true);
+  });
+
+  it('文件不可读（目录当文件）→ 忽略不炸', async () => {
+    const dir = createProjectFixture({ name: 'no-bypass-dir' });
+    expect(await evaluate([dir])).toBe(true);
+  });
+
+  it('多文件任一命中即 fail', async () => {
+    const clean = writeTemp('multi-clean', 'export const x = 1;');
+    const dirty = writeTemp('multi-dirty', VIOLATIONS[0][1]);
+    expect(await evaluate([clean, dirty])).toBe(false);
+  });
+});