@dommaker/harness 1.2.3 → 1.4.0

package/src/core/constraints/__tests__/git-evidence.test.ts

@@ -0,0 +1,208 @@
+/**
+ * git 证据适配器测试（架构评审 #87）
+ *
+ * 覆盖：
+ * - 真 git adapter 在三类证据（staged diff / 变更名 / HEAD 目录）上的取证正确性
+ * - 命令失败语义：diff → ''、ls-tree → null（全部视为新目录）
+ * - memo 落在实例层：同一实例内每条 git 命令至多执行一次
+ * - context-builder 与 checker 共用同一实例 → 一次 run 内无重复 git 命令
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execSync } from 'child_process';
+
+import {
+  createGitEvidence,
+  parseHeadDirs,
+  realGitCommandRunner,
+  type GitCommandRunner,
+  type GitEvidence,
+} from '../git-evidence';
+import { buildConstraintContext } from '../context-builder';
+import { ConstraintChecker } from '../checker';
+import { GUIDELINES } from '../definitions';
+import type { MergedConstraintsConfig } from '../../../types/project-config';
+
+/** 建一个真 git fixture：committed src/existing.ts + 一个 staged 修改 */
+function makeRepo(options: { stagedChange?: boolean } = {}): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-git-evidence-'));
+  execSync('git init -q', { cwd: dir, stdio: 'pipe' });
+  execSync('git config user.email "test@example.com"', { cwd: dir, stdio: 'pipe' });
+  execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe' });
+  fs.mkdirSync(path.join(dir, 'src', 'nested'), { recursive: true });
+  fs.writeFileSync(path.join(dir, 'src', 'existing.ts'), 'export const a = 1;\n');
+  fs.writeFileSync(path.join(dir, 'src', 'nested', 'deep.ts'), 'export const b = 1;\n');
+  fs.writeFileSync(path.join(dir, 'README.md'), '# fixture\n');
+  execSync('git add .', { cwd: dir, stdio: 'pipe' });
+  execSync('git commit -q -m init', { cwd: dir, stdio: 'pipe' });
+  if (options.stagedChange !== false) {
+    fs.writeFileSync(path.join(dir, 'src', 'existing.ts'), 'export const a = 2;\n');
+    execSync('git add src/existing.ts', { cwd: dir, stdio: 'pipe' });
+  }
+  return dir;
+}
+
+/** 记录每条实际执行的 git 命令，执行本身委托真 adapter */
+function countingRunner(): { runner: GitCommandRunner; commands: string[] } {
+  const commands: string[] = [];
+  return {
+    commands,
+    runner: (command, cwd) => {
+      commands.push(command);
+      return realGitCommandRunner(command, cwd);
+    },
+  };
+}
+
+/** 包住一份证据实例，记录「哪个 phase 调了哪个证据方法」（取证是否同源的可观测面） */
+function recordingEvidence(
+  source: GitEvidence,
+  phase: () => string,
+  calls: string[]
+): GitEvidence {
+  return {
+    projectPath: source.projectPath,
+    stagedDiff: () => {
+      calls.push(`${phase()}:stagedDiff`);
+      return source.stagedDiff();
+    },
+    changedFileNames: (staged: boolean) => {
+      calls.push(`${phase()}:changedFileNames`);
+      return source.changedFileNames(staged);
+    },
+    headDirs: () => {
+      calls.push(`${phase()}:headDirs`);
+      return source.headDirs();
+    },
+  };
+}
+
+describe('git 证据适配器（#87）', () => {
+  describe('真 git adapter 取证', () => {
+    it('stagedDiff 返回 staged 全量 diff；changedFileNames 按 staged 选择命令', () => {
+      const dir = makeRepo();
+      const evidence = createGitEvidence(dir);
+
+      expect(evidence.stagedDiff()).toContain('+export const a = 2;');
+      expect(evidence.changedFileNames(true)).toBe('src/existing.ts');
+      // 无未暂存变更 → unstaged diff 为空
+      expect(evidence.changedFileNames(false)).toBe('');
+
+      fs.writeFileSync(path.join(dir, 'src', 'existing.ts'), 'export const a = 3;\n');
+      expect(evidence.changedFileNames(false)).toBe(''); // 实例已 memo，取同一快照
+      expect(createGitEvidence(dir).changedFileNames(false)).toBe('src/existing.ts');
+    });
+
+    it('headDirs 覆盖已提交目录，未提交目录不在集合内', () => {
+      const dir = makeRepo();
+      const dirs = createGitEvidence(dir).headDirs();
+
+      expect(dirs).not.toBeNull();
+      expect(dirs!.has('src')).toBe(true);
+      expect(dirs!.has('src/nested')).toBe(true);
+      fs.mkdirSync(path.join(dir, 'src', 'brand-new'), { recursive: true });
+      expect(createGitEvidence(dir).headDirs()!.has('src/brand-new')).toBe(false);
+    });
+
+    it('非 git 目录：diff 类证据为空串，headDirs 为 null（不重试、不抛错）', () => {
+      const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-git-evidence-'));
+      const { runner, commands } = countingRunner();
+      const evidence = createGitEvidence(dir, runner);
+
+      expect(evidence.stagedDiff()).toBe('');
+      expect(evidence.changedFileNames(true)).toBe('');
+      expect(evidence.headDirs()).toBeNull();
+      // 失败结果同样 memo：重复调用不再 spawn
+      expect(evidence.headDirs()).toBeNull();
+      expect(evidence.changedFileNames(true)).toBe('');
+      expect(commands.length).toBe(3);
+    });
+  });
+
+  describe('parseHeadDirs', () => {
+    it('逐层展开文件路径的父目录', () => {
+      const dirs = parseHeadDirs('src/a/b.ts\nREADME.md\n');
+      expect([...dirs].sort()).toEqual(['src', 'src/a']);
+    });
+  });
+
+  describe('memo 落在实例层', () => {
+    it('同一实例内同类 git 命令至多执行一次', () => {
+      const dir = makeRepo();
+      const { runner, commands } = countingRunner();
+      const evidence = createGitEvidence(dir, runner);
+
+      const first = evidence.stagedDiff();
+      const stagedNames = evidence.changedFileNames(true);
+      const unstagedNames = evidence.changedFileNames(false);
+      const dirs = evidence.headDirs();
+
+      expect(evidence.stagedDiff()).toBe(first);
+      expect(evidence.changedFileNames(true)).toBe(stagedNames);
+      expect(evidence.changedFileNames(false)).toBe(unstagedNames);
+      expect(evidence.headDirs()).toEqual(dirs);
+
+      expect(commands).toEqual([
+        'git diff --cached',
+        'git diff --cached --name-only',
+        'git diff --name-only',
+        'git ls-tree -r --name-only HEAD',
+      ]);
+      expect(new Set(commands).size).toBe(commands.length);
+    });
+
+    it('两个实例 = 两次取证（memo 不是隐式全局）', () => {
+      const dir = makeRepo();
+      const { runner, commands } = countingRunner();
+
+      createGitEvidence(dir, runner).stagedDiff();
+      createGitEvidence(dir, runner).stagedDiff();
+
+      expect(commands.filter(c => c === 'git diff --cached')).toHaveLength(2);
+    });
+  });
+
+  describe('context-builder 与 checker 共用同一证据来源（#87 验收）', () => {
+    it('一次 check run 内同类 git 命令至多执行一次', async () => {
+      const dir = makeRepo();
+      fs.writeFileSync(
+        path.join(dir, 'CAPABILITIES.md'),
+        '# Capabilities\n\n| 模块 | 文件 | 说明 |\n|------|------|------|\n| existing | src/existing.ts | 条目 |\n'
+      );
+      const { runner, commands } = countingRunner();
+      const shared = createGitEvidence(dir, runner);
+      // 记录器：哪个消费者（phase）调了哪个证据方法
+      const phase = { current: 'context' };
+      const calls: string[] = [];
+      const evidence = recordingEvidence(shared, () => phase.current, calls);
+
+      const context = await buildConstraintContext({ projectPath: dir, staged: true, evidence });
+      // capability_sync 经 CheckEnv.stagedDiffNames() 取同一份 git 证据
+      const merged: MergedConstraintsConfig = {
+        ironLaws: {},
+        guidelines: { capability_sync: GUIDELINES['capability_sync'] },
+        prompts: {},
+        custom: [],
+        disabled: [],
+        unknownIds: [],
+      };
+      const checker = new ConstraintChecker({ record: () => undefined });
+      phase.current = 'checker';
+      const runResult = await checker.checkConstraints(context, merged, evidence);
+
+      // capability_sync 确实被评估（非 skip）→ 它经 env.stagedDiffNames() 取过证据
+      expect(runResult.guidelines.map(r => r.id)).toEqual(['capability_sync']);
+      expect(runResult.guidelines[0].skipped).toBeUndefined();
+      // 两个消费者都从注入的这一份实例取证据（checker 没有另起炉灶）
+      expect(calls).toContain('context:changedFileNames');
+      expect(calls).toContain('checker:changedFileNames');
+      // 两侧各自需要同一份 staged 名单，合计只 spawn 一次
+      expect(commands).toEqual([
+        'git diff --cached --name-only',
+        'git ls-tree -r --name-only HEAD',
+      ]);
+    });
+  });
+});

package/src/core/constraints/__tests__/injection-drift.test.ts

@@ -11,7 +11,6 @@
  */
 
 import * as fs from 'fs';
-import * as os from 'os';
 import * as path from 'path';
 import { detectInjectionDrift, INJECTION_DRIFT_FIX_HINT } from '../injection-drift';
 import {
@@ -19,12 +18,11 @@ import {
   CONSTRAINTS_START_MARKER,
 } from '../injection-renderer';
 import { getEffectiveConstraints } from '../../effective-constraints';
+import { createProjectFixture, writeProjectConfig } from '../../../test-setup/project-fixture';
 
 const TEST_VERSION = '9.9.9-test';
 
-function makeTmpProject(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'harness-drift-test-'));
-}
+const makeTmpProject = (): string => createProjectFixture({ name: 'harness-drift-test' });
 
 /** 写入与当前生效集完全一致的注入段（版本 TEST_VERSION） */
 function writeSyncedClaudeMd(root: string, extra = ''): string {
@@ -102,12 +100,7 @@ describe('detectInjectionDrift', () => {
     const root = makeTmpProject();
     writeSyncedClaudeMd(root);
     // 注入后禁用一条 prompt，但不重跑 init
-    fs.mkdirSync(path.join(root, '.harness'), { recursive: true });
-    fs.writeFileSync(
-      path.join(root, '.harness', 'config.yml'),
-      'constraints:\n  no_fuzzy_completion_claim:\n    enabled: false\n',
-      'utf-8'
-    );
+    writeProjectConfig(root, 'constraints:\n  no_fuzzy_completion_claim:\n    enabled: false\n');
 
     const drift = detectInjectionDrift(root, TEST_VERSION);
 

package/src/core/constraints/__tests__/injection-writer.test.ts

@@ -0,0 +1,231 @@
+/**
+ * injection-writer 旁测（架构评审候选1，ADR-0011）
+ *
+ * 测试面 = 纯函数（字符串进、字符串出）+ 落点路由（真实 fs 临时目录）。
+ * 幂等/半标记守护/两种尾部形状/读写路由优先级全部在此测一次；
+ * 消费方（init/retire/drift）只测各自语义（init-injection.test 行为面）。
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  replaceStandaloneRange,
+  replaceEnclosedRange,
+  cutMarkerBlock,
+  resolveInjectionTarget,
+  resolveGovernanceLanding,
+  GOVERNANCE_HEADING,
+  hasGovernanceContract,
+  countGovernanceHeadings,
+  hasPreserveBlock,
+} from '../injection-writer';
+import {
+  CONSTRAINTS_START_MARKER as CS,
+  CONSTRAINTS_END_MARKER as CE,
+} from '../injection-renderer';
+
+const B = '<!-- B -->';
+const E = '<!-- E -->';
+
+describe('replaceStandaloneRange — 独立成节形状', () => {
+  it('替换含标记区间；尾文多换行折叠为恰好一个空行', () => {
+    const content = `head\n${B}\nold\n${E}\n\n\n\nrest\n`;
+    const r = replaceStandaloneRange(content, B, E, `${B}\nnew\n${E}\n`);
+    expect(r).toEqual({ kind: 'updated', content: `head\n${B}\nnew\n${E}\n\nrest\n` });
+  });
+
+  it('尾文恰好一个空行分隔（含原本无多余换行时）', () => {
+    const content = `${B}\nold\n${E}\nrest\n`;
+    const r = replaceStandaloneRange(content, B, E, `${B}\nnew\n${E}\n`);
+    expect(r).toEqual({ kind: 'updated', content: `${B}\nnew\n${E}\n\nrest\n` });
+  });
+
+  it('区间在文件末尾：不产生尾空行', () => {
+    const content = `head\n${B}\nold\n${E}\n`;
+    const r = replaceStandaloneRange(content, B, E, `${B}\nnew\n${E}\n`);
+    expect(r).toEqual({ kind: 'updated', content: `head\n${B}\nnew\n${E}\n` });
+  });
+
+  it('幂等：重复替换结果不动点', () => {
+    const once = replaceStandaloneRange(`a\n${B}\nx\n${E}\n\n\nb\n`, B, E, `${B}\nnew\n${E}\n`);
+    expect(once.kind).toBe('updated');
+    const twice = replaceStandaloneRange((once as { content: string }).content, B, E, `${B}\nnew\n${E}\n`);
+    expect(twice).toEqual(once);
+  });
+
+  it('两俱无 → absent；单边/乱序 → half（拒写）', () => {
+    expect(replaceStandaloneRange('nothing here', B, E, 'x')).toEqual({ kind: 'absent' });
+    expect(replaceStandaloneRange(`${B}\norphan`, B, E, 'x')).toEqual({ kind: 'half' });
+    expect(replaceStandaloneRange(`orphan ${E}`, B, E, 'x')).toEqual({ kind: 'half' });
+    expect(replaceStandaloneRange(`${E}\n...\n${B}`, B, E, 'x')).toEqual({ kind: 'half' });
+  });
+});
+
+describe('replaceEnclosedRange — 外层收口紧随形状', () => {
+  it('恰好剥一个前导换行，手写余文的额外换行原样保留', () => {
+    const inner = `\n## H\n${CS}\nold\n${CE}\n\n手写余文\n`;
+    const r = replaceEnclosedRange(inner, CS, CE, `${CS}\nnew\n${CE}\n`);
+    expect(r).toEqual({ kind: 'updated', content: `\n## H\n${CS}\nnew\n${CE}\n\n手写余文\n` });
+  });
+
+  it('区间后仅有行尾换行（收口标记直接落行）', () => {
+    const inner = `\n${CS}\nold\n${CE}\n`;
+    const r = replaceEnclosedRange(inner, CS, CE, `${CS}\nnew\n${CE}\n`);
+    expect(r).toEqual({ kind: 'updated', content: `\n${CS}\nnew\n${CE}\n` });
+  });
+
+  it('absent → 调用方走追加；half → 拒写', () => {
+    expect(replaceEnclosedRange('\n纯手写段\n', CS, CE, 'x')).toEqual({ kind: 'absent' });
+    expect(replaceEnclosedRange(`${CS}orphan`, CS, CE, 'x')).toEqual({ kind: 'half' });
+  });
+});
+
+describe('cutMarkerBlock', () => {
+  it('切出 before/inner/after 三段，inner 含首尾标记行间全部文本', () => {
+    const content = `before\n${B}\ninner-body\n${E}\nafter\n`;
+    expect(cutMarkerBlock(content, B, E)).toEqual({
+      before: 'before\n',
+      inner: '\ninner-body\n',
+      after: '\nafter\n',
+    });
+  });
+
+  it('absent / half 与替换函数同一判定', () => {
+    expect(cutMarkerBlock('clean', B, E)).toBe('absent');
+    expect(cutMarkerBlock(`${B} only`, B, E)).toBe('half');
+  });
+});
+
+describe('落点路由（读写两侧，studio #307/#302）', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(process.cwd(), 'temp-test-inj-writer-'));
+  });
+  afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
+
+  const write = (name: string, content: string) =>
+    fs.writeFileSync(path.join(dir, name), content, 'utf-8');
+
+  it('resolveInjectionTarget：CLAUDE.md 完整标记段优先于 AGENTS.md', () => {
+    write('CLAUDE.md', `x\n${CS}\nbody\n${CE}\n`);
+    write('AGENTS.md', `<!-- PRESERVE:governance -->\n${CS}\nbody2\n${CE}\n`);
+    expect(resolveInjectionTarget(dir)?.file).toBe('CLAUDE.md');
+  });
+
+  it('CLAUDE.md 标记残缺（单边）不算落点 → 落 AGENTS.md', () => {
+    write('CLAUDE.md', `x\n${CS}\nbroken\n`);
+    write('AGENTS.md', `${CS}\nbody\n${CE}\n`);
+    expect(resolveInjectionTarget(dir)?.file).toBe('AGENTS.md');
+  });
+
+  it('两处均无完整标记段 → null（未注入）', () => {
+    write('CLAUDE.md', '# 无约束标记\n');
+    expect(resolveInjectionTarget(dir)).toBeNull();
+  });
+
+  it('resolveGovernanceLanding：CLAUDE.md 有标记或有旧版 Governance Rules 块 → claude-md', () => {
+    write('CLAUDE.md', `${CS}\nbody\n${CE}\n`);
+    expect(resolveGovernanceLanding(dir).target).toBe('claude-md');
+    write('CLAUDE.md', '# CLAUDE.md\n\n## Governance Rules\n\n手写\n');
+    expect(resolveGovernanceLanding(dir).target).toBe('claude-md');
+  });
+
+  it('CLAUDE.md 与治理无关 / 不存在 → agents-md', () => {
+    write('CLAUDE.md', '# CLAUDE.md\n\n@AGENTS.md\n');
+    expect(resolveGovernanceLanding(dir).target).toBe('agents-md');
+    fs.rmSync(path.join(dir, 'CLAUDE.md'));
+    expect(resolveGovernanceLanding(dir).target).toBe('agents-md');
+  });
+
+  it('落点路由消费共享宽松谓词：双空格标题变体也路由 claude-md（fail-open）', () => {
+    write('CLAUDE.md', '# CLAUDE.md\n\n##  Governance Rules\n\n手写\n');
+    expect(resolveGovernanceLanding(dir).target).toBe('claude-md');
+  });
+});
+
+describe('治理契约探测共享符号（#83，ADR-0011 补注：收口范围含探测器）', () => {
+  it('GOVERNANCE_HEADING 是标题字面量单一来源', () => {
+    expect(GOVERNANCE_HEADING).toBe('## Governance Rules');
+  });
+
+  describe('hasGovernanceContract — 宽松谓词（有无契约，fail-open）', () => {
+    it('精确标题 → true', () => {
+      expect(hasGovernanceContract('# doc\n\n## Governance Rules\n\n条款\n')).toBe(true);
+    });
+
+    it('双空格标题变体 → true（宁可信其有）', () => {
+      expect(hasGovernanceContract('# doc\n\n##  Governance Rules\n\n条款\n')).toBe(true);
+    });
+
+    it('HARNESS 约束标记在场 → true（完整注释壳与裸文本皆认）', () => {
+      expect(hasGovernanceContract('<!-- HARNESS_CONSTRAINTS_START -->\nx\n')).toBe(true);
+      expect(hasGovernanceContract('HARNESS_CONSTRAINTS_START\nx\n')).toBe(true);
+    });
+
+    it('两样皆无 → false', () => {
+      expect(hasGovernanceContract('# CLAUDE.md\n\n@AGENTS.md\n')).toBe(false);
+    });
+  });
+
+  describe('countGovernanceHeadings — 严格计数（正本标题，行尾锚定）', () => {
+    it('精确拼写逐个计数', () => {
+      expect(countGovernanceHeadings('## Governance Rules\n')).toBe(1);
+      expect(countGovernanceHeadings('## Governance Rules\n甲\n\n## Governance Rules\n乙\n')).toBe(2);
+    });
+
+    it('行尾空白容忍', () => {
+      expect(countGovernanceHeadings('## Governance Rules  \n')).toBe(1);
+      expect(countGovernanceHeadings('## Governance Rules\t\n')).toBe(1);
+    });
+
+    it('宽松变体不计入：双空格 / 三级标题 / 行中嵌入 → 0', () => {
+      expect(countGovernanceHeadings('##  Governance Rules\n')).toBe(0);
+      expect(countGovernanceHeadings('### Governance Rules\n')).toBe(0);
+      expect(countGovernanceHeadings('前文 ## Governance Rules 行中\n')).toBe(0);
+    });
+  });
+
+  describe('hasPreserveBlock — PRESERVE 块存在性 + 块体非空', () => {
+    const begin = '<!-- PRESERVE:governance -->';
+    const end = '<!-- /PRESERVE:governance -->';
+
+    it('块体非空 + 首尾标记独占一行 → true', () => {
+      expect(hasPreserveBlock(`# t\n${begin}\n## H\n条款\n${end}\n`, 'governance')).toBe(true);
+    });
+
+    it('块体仅空白 → false（被掏空）', () => {
+      expect(hasPreserveBlock(`${begin}\n   \n${end}\n`, 'governance')).toBe(false);
+      expect(hasPreserveBlock(`${begin}\n\n${end}\n`, 'governance')).toBe(false);
+    });
+
+    it('结束标记嵌在行中 = 畸形块 → false（显式收紧，#83）', () => {
+      expect(hasPreserveBlock(`${begin}\n条款 <!-- /PRESERVE:governance --> 尾注\n`, 'governance')).toBe(false);
+    });
+
+    it('结束标记缺失 / 乱序 → false', () => {
+      expect(hasPreserveBlock(`${begin}\n条款\n`, 'governance')).toBe(false);
+      expect(hasPreserveBlock(`${end}\n${begin}\n`, 'governance')).toBe(false);
+    });
+
+    it('开始标记不在 / 名称不符 → false', () => {
+      expect(hasPreserveBlock('没有标记\n', 'governance')).toBe(false);
+      expect(hasPreserveBlock(`${begin}\n条款\n${end}\n`, 'other')).toBe(false);
+    });
+
+    it('标记行行尾空白容忍（独占一行语义）', () => {
+      expect(hasPreserveBlock(`${begin}  \n条款\n${end}  \n`, 'governance')).toBe(true);
+    });
+  });
+
+  it('一致性 fixture：双空格 → 宽松在场 true 且严格计数 0；精确拼写 → 两者均认', () => {
+    const variant = '# CLAUDE.md\n\n##  Governance Rules\n\n条款\n';
+    expect(hasGovernanceContract(variant)).toBe(true);
+    expect(countGovernanceHeadings(variant)).toBe(0);
+
+    const exact = '# CLAUDE.md\n\n## Governance Rules\n\n条款\n';
+    expect(hasGovernanceContract(exact)).toBe(true);
+    expect(countGovernanceHeadings(exact)).toBe(1);
+  });
+});

package/src/core/constraints/__tests__/trace-injection.test.ts

@@ -0,0 +1,71 @@
+/**
+ * trace 记录器注入（工单 15 decycle 收尾 / harness#88）
+ *
+ * 原状态：checker 值导入 monitoring 的 getTraceCollector，并在首次记录时惰性接线
+ * （ADR-0003），`setTraceRecorder` 退化成只有测试在用的假 seam。
+ * 现在：记录器经**构造参数**注入；未注入 = no-op（core 零上行依赖，默认无副作用），
+ * 真实收集器由组合根（CLI 命令 / bootstrap）接线。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ConstraintChecker } from '../checker';
+import type { ExecutionTrace } from '../../../types/trace';
+
+jest.mock('../../../monitoring/traces', () => ({
+  getTraceCollector: jest.fn(() => ({ record: jest.fn() })),
+  TraceCollector: jest.fn(),
+  configureTraceCollector: jest.fn(),
+}));
+
+/** 替身收集器工厂（core 侧连测试也不值导入 monitoring，方向由 #88 规则锁） */
+const getTraceCollector = jest.requireMock('../../../monitoring/traces')
+  .getTraceCollector as jest.Mock;
+
+describe('trace 记录器构造注入（harness#88）', () => {
+  let projectDir: string;
+  /** 与 skip-semantics 同族的 fixture：目录不存在 → 存在性探测走 skip，不阻断 */
+  const context = () => ({
+    operation: 'code_implementation' as const,
+    projectPath: path.join(projectDir, 'not-created'),
+  });
+
+  beforeAll(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-trace-injection-'));
+    getTraceCollector.mockClear();
+  });
+
+  afterAll(() => {
+    try {
+      fs.rmSync(projectDir, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  it('构造注入的记录器收到每条约束的 trace', async () => {
+    const records: ExecutionTrace[] = [];
+    const checker = new ConstraintChecker({ record: (t) => records.push(t) });
+
+    await checker.checkConstraints(context());
+
+    expect(records.map(r => r.constraintId)).toEqual(
+      expect.arrayContaining(['incremental_progress', 'no_implementation_without_requirement'])
+    );
+    expect(records.every(r => ['pass', 'fail', 'skip'].includes(r.result))).toBe(true);
+  });
+
+  it('setTraceRecorder 假 seam 已删除', () => {
+    const checker = new ConstraintChecker({ record: () => undefined });
+    expect((checker as any).setTraceRecorder).toBeUndefined();
+  });
+
+  it('未注入记录器时不记录，也不反向取全局收集器（core 零上行依赖）', async () => {
+    const unwired = new ConstraintChecker();
+
+    await unwired.checkConstraints(context());
+
+    expect(getTraceCollector).not.toHaveBeenCalled();
+  });
+});

package/src/core/constraints/__tests__/usage-report.test.ts

@@ -0,0 +1,112 @@
+/**
+ * traces.log 坏行 fixture（harness#82 + harness#100）
+ *
+ * #82：三种现行响应例证之「静默跳过」（原语义不变）——
+ * traces.log 单行损坏时 report 数据层不失败，返回全部合法 trace。
+ * #100：计数不再断在 module 层——新增 `readProjectTracesReport()` 报告入口，
+ * 并把坏行数挂进 `ConstraintsUsageReport`（与 `traceFileExists` 同一降级维度）。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { createProjectFixture } from '../../../test-setup/project-fixture';
+import { readJsonl } from '../../../utils/jsonl';
+import {
+  buildConstraintsUsageReport,
+  readProjectTraces,
+  readProjectTracesReport,
+} from '../usage-report';
+import { DEFAULT_TRACE_FILE } from '../../../types/trace';
+
+describe('readProjectTraces 坏行容错（harness#82）', () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-usage-report-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  function writeTraces(lines: string[]): void {
+    const tracePath = path.join(root, DEFAULT_TRACE_FILE);
+    fs.mkdirSync(path.dirname(tracePath), { recursive: true });
+    fs.writeFileSync(tracePath, lines.join('\n') + '\n', 'utf-8');
+  }
+
+  it('坏行静默跳过，返回全部合法 trace', () => {
+    writeTraces([
+      '{"constraintId":"a","level":"iron_law","timestamp":1,"result":"pass"}',
+      '{"constraintId":"b","broken',
+      '{"constraintId":"c","level":"iron_law","timestamp":3,"result":"fail"}',
+    ]);
+    const traces = readProjectTraces(root);
+    expect(traces.map(t => t.constraintId)).toEqual(['a', 'c']);
+  });
+
+  it('缺文件返回空数组', () => {
+    expect(readProjectTraces(root)).toEqual([]);
+  });
+});
+
+describe('坏行计数透传到 report 数据层（harness#100）', () => {
+  const VALID_A = '{"constraintId":"a","level":"iron_law","timestamp":1,"result":"pass"}';
+  const VALID_B = '{"constraintId":"b","level":"iron_law","timestamp":3,"result":"fail"}';
+  const BAD = '{"constraintId":"x","broken';
+  const TRACE_REL = path.join('.harness', 'logs', 'traces.log');
+
+  function projectWith(lines: string[]): string {
+    return createProjectFixture({
+      name: 'usage-report-skiplines',
+      files: { [TRACE_REL]: lines.join('\n') + '\n' },
+    });
+  }
+
+  it.each([
+    [1, [BAD]],
+    [3, [BAD, 'garbage', '{"half"]  }']],
+  ] as Array<[number, string[]]>)(
+    '%i 行坏数据：readProjectTracesReport 计数与 module 计数对账',
+    (expectedSkipped, badLines) => {
+      const lines = [VALID_A, ...badLines, VALID_B];
+      const root = projectWith(lines);
+
+      const report = readProjectTracesReport(root);
+
+      expect(report.skippedLines).toBe(expectedSkipped);
+      expect(report.skippedLines).toBe(
+        readJsonl(path.join(root, TRACE_REL), 'skip').skippedLines
+      );
+      // 兼容签名不变：旧入口仍只返回合法记录数组
+      expect(readProjectTraces(root)).toEqual(report.traces);
+      expect(report.traces.map(t => t.constraintId)).toEqual(['a', 'b']);
+    }
+  );
+
+  it('buildConstraintsUsageReport 报告体带坏行数（与 traceFileExists 同一降级维度）', () => {
+    const root = projectWith([VALID_A, BAD, VALID_B]);
+
+    const report = buildConstraintsUsageReport(root);
+
+    expect(report.skippedLines).toBe(1);
+    expect(report.traceFileExists).toBe(true);
+  });
+
+  it('无损坏时计数为 0（既有输出零噪声的前提）', () => {
+    const report = buildConstraintsUsageReport(projectWith([VALID_A, VALID_B]));
+
+    expect(report.skippedLines).toBe(0);
+    expect(report.traceFileExists).toBe(true);
+  });
+
+  it('缺 trace 文件：计数 0 且 traceFileExists=false', () => {
+    const report = buildConstraintsUsageReport(
+      createProjectFixture({ name: 'usage-report-notracefile' })
+    );
+
+    expect(report.skippedLines).toBe(0);
+    expect(report.traceFileExists).toBe(false);
+  });
+});

package/src/core/constraints/agent-prompt-renderer.ts

@@ -11,8 +11,8 @@
  * （如 docs_freshness）不渲染。
  */
 
-import type { Constraint, ConstraintLevel, ConstraintTrigger } from '../../types/constraint';
-import { normalizeTriggers } from '../../utils/exec';
+import type { ConstraintLevel, ConstraintTrigger } from '../../types/constraint';
+import { matchesTrigger } from '../../utils/exec';
 import { getEffectiveConstraints } from '../effective-constraints';
 
 /**
@@ -65,7 +65,3 @@ export function renderConstraintsByTrigger(
   }
   return lines.join('\n');
 }
-
-function matchesTrigger(constraint: Constraint, requested: ConstraintTrigger[]): boolean {
-  return normalizeTriggers<ConstraintTrigger>(constraint.trigger).some(t => requested.includes(t));
-}