@dommaker/harness 1.7.0 → 1.8.1

package/src/cli/commands/__tests__/check-read-count.test.ts

@@ -0,0 +1,170 @@
+/**
+ * 一次 check 运行内「每个项目文件至多读一次」计数闸（ADR-0023 决策 5 ①）
+ *
+ * 形状照 `check.test.ts:78-106` 的 `recordingEvidence()`：真执行、只在中间记一笔，
+ * 不改任何行为。这里数的不是「观察口被请求几次」（memo 在观察面上，请求多次本就应当），
+ * 而是**底层文件读取发生了几次** —— 那才是本 ADR 承诺的口径。
+ *
+ * 夹具必须让两个吃能力表的 checker 都真评估（触发条件 module_modification +
+ * 有 CAPABILITIES.md + 有自定义约束文件），否则闸门是空跑的。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { execFileSync } from 'child_process';
+import { check } from '../check';
+import { captureIO, type CapturingIO } from '../../command-contract';
+
+type ReadCall = { file: string; via: 'readFileSync' | 'open' };
+
+// 计数器挂在 globalThis：jest.mock 工厂会被提前调用，闭包外提会撞 TDZ
+jest.mock('fs', () => {
+  const actual = jest.requireActual<typeof import('fs')>('fs');
+  const g = globalThis as unknown as { __ADR0023_READS__?: ReadCall[] };
+  if (!g.__ADR0023_READS__) g.__ADR0023_READS__ = [];
+  const bucket = g.__ADR0023_READS__;
+  const name = (p: unknown): string =>
+    Buffer.isBuffer(p) ? p.toString('utf8') : String(p);
+  const passthrough = (fn: string) =>
+    (actual as unknown as Record<string, (...args: unknown[]) => unknown>)[fn];
+
+  return {
+    ...actual,
+    readFileSync: jest.fn((p: unknown, ...rest: unknown[]) => {
+      bucket.push({ file: name(p), via: 'readFileSync' });
+      return passthrough('readFileSync')(p, ...rest);
+    }),
+    // 有界读走 open/fstat/read：只记只读打开（写 trace 的 append 不算读取）
+    openSync: jest.fn((p: unknown, flags?: unknown, ...rest: unknown[]) => {
+      if (flags === undefined || flags === 'r' || flags === 'rs') {
+        bucket.push({ file: name(p), via: 'open' });
+      }
+      return passthrough('openSync')(p, flags, ...rest);
+    }),
+  };
+});
+
+const reads = () =>
+  ((globalThis as unknown as { __ADR0023_READS__?: ReadCall[] }).__ADR0023_READS__ ||= []);
+
+jest.mock('chalk', () => ({
+  blue: (s: string) => s,
+  yellow: (s: string) => s,
+  green: (s: string) => s,
+  gray: (s: string) => s,
+  red: (s: string) => s,
+}));
+
+function git(dir: string, ...args: string[]): void {
+  execFileSync('git', args, { cwd: dir, stdio: 'pipe' });
+}
+
+function write(dir: string, rel: string, content: string): void {
+  const target = path.join(dir, rel);
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.writeFileSync(target, content, 'utf-8');
+}
+
+const TABLE = ['| 能力 | 路径 | 说明 |', '|---|---|---|'];
+
+/** 一个「两 checker 都会真评估」的项目：源码根下两个已登记文件 + 自定义约束 + 一条 trace */
+function fixtureRepo(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-read-count-'));
+  git(dir, 'init', '-q');
+  git(dir, 'config', 'user.email', 'fixture@example.com');
+  git(dir, 'config', 'user.name', 'Fixture');
+  write(dir, 'README.md', '# fixture\n');
+  write(dir, '.harness/config.yml', 'preset: standard\n');
+  write(
+    dir,
+    '.harness/custom-constraints.yml',
+    'custom_constraints:\n  ab_custom_rule:\n    level: guideline\n    rule: 自定义规则\n    message: 自定义提示\n    trigger: manual\n'
+  );
+  write(
+    dir,
+    'CAPABILITIES.md',
+    ['# CAPABILITIES.md', '', ...TABLE, '| 既有 | src/existing.ts | 在 |', '| 嵌套 | src/nested/deep.ts | 在 |'].join('\n') + '\n'
+  );
+  write(dir, 'AGENTS.md', '<!-- PRESERVE:governance -->\n## Governance Rules\n\n条款\n\n<!-- /PRESERVE:governance -->\n');
+  write(dir, 'src/existing.ts', 'export const a = 1;\n');
+  write(dir, 'src/nested/deep.ts', 'export const d = 1;\n');
+  write(dir, '.harness/logs/traces.log', '{"constraintId":"fixture","result":"pass"}\n');
+  // ADR-0026：状态文件进夹具，智能提示的状态读取随之进计数表（一次运行至多读一次）
+  write(dir, '.harness/.state.json', '{}');
+  git(dir, 'add', '.');
+  git(dir, 'commit', '-q', '-m', 'baseline');
+  // 改一个已登记的源文件并 stage → 触发条件 module_modification
+  write(dir, 'src/existing.ts', 'export const a = 2;\n');
+  git(dir, 'add', '--', 'src/existing.ts');
+  return dir;
+}
+
+describe('一次 check 的文件读取计数闸（ADR-0023 决策 5 ①）', () => {
+  let io: CapturingIO;
+  let dir: string;
+
+  /** 相对项目根的文件名 → 读取次数（只读语义的 readFileSync 与只读 open 都算一次） */
+  function readCounts(): Map<string, number> {
+    const counts = new Map<string, number>();
+    for (const call of reads()) {
+      const rel = path.relative(dir, call.file);
+      if (!rel || rel.startsWith('..')) continue; // 非本项目文件（模块加载等）不计
+      counts.set(rel, (counts.get(rel) ?? 0) + 1);
+    }
+    return counts;
+  }
+
+  beforeEach(() => {
+    // 原地清空：mock 工厂在装载时就captured了这个数组引用，换新数组计数会落到旧的去向（假绿）
+    reads().length = 0;
+    io = captureIO();
+    dir = fixtureRepo();
+    // trace 自 #139 起锚在 projectPath 上写入（本夹具内），写入不经读取计数器
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('整张读取表如实冻结：本次运行读了哪些项目文件、各读几次', async () => {
+    const result = await check({ staged: true, projectPath: dir }, io);
+    expect(result.kind).toBe('ok');
+    // 正对照：两个吃能力表的 checker 确实跑了（否则下面的断言是空跑）
+    expect(io.outText()).toContain('自定义约束: 1 条');
+    expect(io.outText()).toContain('触发条件: module_modification');
+
+    expect([...readCounts().entries()].sort()).toEqual(
+      [
+        // —— 一次运行一份：本 ADR 的承诺面 ——
+        ['.harness/config.yml', 1],
+        ['.harness/custom-constraints.yml', 1],
+        ['CAPABILITIES.md', 1],
+        ['.harness/logs/traces.log', 2],
+        ['.harness/.state.json', 1], // ADR-0026：智能提示经 StateIO 读状态，恰一次
+        // —— 已知例外（改动需明写理由）——
+        // traces.log = 2：head 50（智能提示的阈值判定，决策 3）与 tail 20（有无失败证据，
+        // 决策 4）是两个不同窗口的**有界**读；并成一个窗口就等于回到整读。
+        // AGENTS.md = 3 / CLAUDE.md = 2：决策表明示本 ADR 不处理治理文档的重复读
+        // （1.5–25KB，<1ms）。CLAUDE.md 在本夹具里并不存在，2 = 落点路由与旧落点兜底
+        // 各尝试读一次（读失败的尝试同样计入）。
+        ['AGENTS.md', 3],
+        ['CLAUDE.md', 2],
+      ].sort()
+    );
+  });
+
+  it('除上表点名例外外的项目文件，一次运行内一律至多读一次', async () => {
+    await check({ staged: true, projectPath: dir }, io);
+
+    const except = new Set([
+      path.join('.harness', 'logs', 'traces.log'), // 两个窗口的有界读，见上表理由
+      'AGENTS.md', // 治理文档，ADR-0023 决策表明示不处理
+      'CLAUDE.md',
+    ]);
+    const offenders = [...readCounts()].filter(
+      ([file, n]) => !except.has(file) && n > 1
+    );
+    expect(offenders).toEqual([]);
+  });
+});

package/src/cli/commands/__tests__/check-skip-output.test.ts

@@ -34,8 +34,11 @@ jest.mock('../../../core/constraints/checker', () => ({
   }),
 }));
 
+// 命令 per-run 锚根构造收集器（harness#139）：构造替身即拦截 trace 落盘
 jest.mock('../../../monitoring/traces', () => ({
-  getTraceCollector: jest.fn(() => ({ record: jest.fn() })),
+  TraceCollector: jest.fn(function () {
+    return { record: jest.fn() };
+  }),
 }));
 
 // Mock effective-constraints（ADR-0001：check 经 getMergedConstraintsConfig 走生效集链路）

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

@@ -7,8 +7,8 @@
  * 真 ConstraintChecker，断言 CLI 输出形状与 CommandResult。
  * 取证次数经 createGitEvidence 的计数 runner 观测——执行仍走真 git，不 mock 子进程。
  *
- * trace 记录器由命令侧组合根接线（harness#88）：套件把全局收集器重定向到临时文件，
- * 既不断言宿主仓写入，也不污染它。
+ * trace 记录器由命令侧组合根接线（harness#88）并锚根构造（#139）：落点在本用例的
+ * 临时项目里（`<projectPath>/.harness/logs/traces.log`），宿主仓 .harness/ 不受影响。
  */
 
 import * as fs from 'fs';
@@ -18,7 +18,8 @@ import { execFileSync } from 'child_process';
 
 import { check, listLaws } from '../check';
 import { captureIO, type CapturingIO } from '../../command-contract';
-import { configureTraceCollector } from '../../../monitoring/traces';
+import type { HarnessState, StateIO } from '../../state-io';
+import { DEFAULT_TRACE_FILE } from '../../../types/trace';
 import {
   createGitEvidence,
   realGitCommandRunner,
@@ -75,6 +76,36 @@ function passTraces(dir: string, lines = 1): void {
   );
 }
 
+/**
+ * 本项目的 trace 落点记录（harness#139：命令侧收集器锚根构造，写的就是 `<projectPath>/DEFAULT_TRACE_FILE` 正本）
+ *
+ * 含 `passTraces()` 预置的种子行，只看命令自己写入的用例按行数切掉前缀。
+ */
+function projectTraces(
+  dir: string
+): Array<{ constraintId: string; result: string; projectPath?: string; evidence?: string[] }> {
+  const file = path.join(dir, DEFAULT_TRACE_FILE);
+  if (!fs.existsSync(file)) return [];
+  return fs
+    .readFileSync(file, 'utf-8')
+    .split('\n')
+    .filter(Boolean)
+    .map(line => JSON.parse(line));
+}
+
+/**
+ * 内存 StateIO 假件（ADR-0026）：状态相关测试经注入面驱动，不碰真文件系统。
+ * `snapshot()` 给断言用——读的是假件当前持有的状态，不是磁盘。
+ */
+function memoryStateIO(initial: HarnessState = {}): StateIO & { snapshot(): HarnessState } {
+  let state = initial;
+  return {
+    read: () => state,
+    write: (next: HarnessState) => { state = next; },
+    snapshot: () => state,
+  };
+}
+
 /** 计数 git 证据：既记录证据方法请求，也记录实际 spawn 的 git 命令（执行走真 adapter） */
 function recordingEvidence(projectPath: string): {
   evidence: GitEvidence;
@@ -118,28 +149,9 @@ function stagedTestDeletion(): string {
 
 describe('check command（真 git fixture）', () => {
   let io: CapturingIO;
-  let traceDir: string;
-  let traceFile: string;
-  let traceSeq = 0;
-
-  beforeAll(() => {
-    traceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-check-traces-'));
-  });
-
-  afterAll(() => {
-    configureTraceCollector({});
-    try {
-      fs.rmSync(traceDir, { recursive: true, force: true });
-    } catch {
-      // ignore
-    }
-  });
 
   beforeEach(() => {
     io = captureIO();
-    // 命令侧接线的是全局收集器（默认 cwd 相对写入）：重定向到套件临时文件，宿主仓 .harness/ 不受影响
-    traceFile = path.join(traceDir, `trace-${++traceSeq}.log`);
-    configureTraceCollector({ traceFile });
   });
 
   describe('判定与输出形状', () => {
@@ -240,6 +252,22 @@ describe('check command（真 git fixture）', () => {
       expect(io.outText()).not.toContain('变更文件');
       expect(result).toEqual({ kind: 'ok' });
     });
+
+    it('不带 -p 时标注预设来源，带 -p 时打印所传值（ADR-0023 步骤 4.5）', async () => {
+      const dir = gitRepo();
+      stageChange(dir, 'src/existing.ts', 'export const a = 2;\n');
+      passTraces(dir);
+
+      await check({ staged: true, projectPath: dir, trigger: 'code_implementation' }, io);
+      await check(
+        { preset: 'standard', staged: true, projectPath: dir, trigger: 'code_implementation' },
+        io
+      );
+
+      const out = io.outText();
+      expect(out).toContain('预设: （按 config.yml，缺省 standard）');
+      expect(out).toContain('预设: standard');
+    });
   });
 
   describe('判定证据外显（harness#119）', () => {
@@ -255,14 +283,9 @@ describe('check command（真 git fixture）', () => {
       return dir;
     }
 
-    /** 从本用例 trace 文件里取某条约束的记录 */
-    function traceOf(constraintId: string) {
-      return fs
-        .readFileSync(traceFile, 'utf-8')
-        .split('\n')
-        .filter(Boolean)
-        .map((line) => JSON.parse(line) as { constraintId: string; result: string; evidence?: string[] })
-        .find((l) => l.constraintId === constraintId);
+    /** 从本用例项目的 trace 正本里取某条约束的记录（#139：落点锚在 projectPath） */
+    function traceOf(dir: string, constraintId: string) {
+      return projectTraces(dir).find(l => l.constraintId === constraintId);
     }
 
     it('变更文件未登记 → 警告随附证据点名该文件', async () => {
@@ -308,7 +331,7 @@ describe('check command（真 git fixture）', () => {
         io
       );
 
-      const record = traceOf('capability_sync');
+      const record = traceOf(dir, 'capability_sync');
       expect(record?.result).toBe('pass');
       expect(record?.evidence?.join('\n')).toContain('src/nested/deep.ts');
     });
@@ -364,17 +387,15 @@ describe('check command（真 git fixture）', () => {
       const dir = gitRepo();
       stageChange(dir, 'src/existing.ts', 'export const a = 2;\n');
       passTraces(dir);
+      const seeded = projectTraces(dir).length;
 
       await check(
         { preset: 'standard', staged: true, projectPath: dir, trigger: 'code_implementation' },
         io
       );
 
-      const traces = fs
-        .readFileSync(traceFile, 'utf-8')
-        .split('\n')
-        .filter(Boolean)
-        .map(l => JSON.parse(l) as { constraintId: string; result: string; projectPath: string });
+      // #139：落点锚在本 run 的 projectPath 上，切掉夹具预置的证据行
+      const traces = projectTraces(dir).slice(seeded);
 
       expect(traces.map(t => t.constraintId)).toEqual(
         expect.arrayContaining(['incremental_progress', 'no_implementation_without_requirement'])
@@ -475,27 +496,25 @@ describe('check command（真 git fixture）', () => {
     });
   });
 
-  describe('智能提示（真 traces.log 与状态文件）', () => {
+  describe('智能提示（真 traces.log + 注入 StateIO 假件）', () => {
     it('记录数首次达到 50 时提示，并落盘已提示状态', async () => {
       const dir = gitRepo();
       passTraces(dir, 50);
+      const stateIO = memoryStateIO();
 
-      await check({ preset: 'standard', staged: true, projectPath: dir, trigger: 'manual' }, io);
+      await check({ preset: 'standard', staged: true, projectPath: dir, trigger: 'manual', stateIO }, io);
 
       expect(io.outText()).toContain('记录已足够，运行 harness status 查看统计');
       expect(io.outText()).toContain('────────────────');
-      const state = JSON.parse(
-        fs.readFileSync(path.join(dir, '.harness', '.state.json'), 'utf-8')
-      );
-      expect(state.shownHints).toContain('trace_50');
+      expect(stateIO.snapshot().shownHints).toContain('trace_50');
     });
 
     it('已提示过的不再重复提示', async () => {
       const dir = gitRepo();
       passTraces(dir, 50);
-      write(dir, '.harness/.state.json', JSON.stringify({ shownHints: ['trace_50'] }));
+      const stateIO = memoryStateIO({ shownHints: ['trace_50'] });
 
-      await check({ preset: 'standard', staged: true, projectPath: dir, trigger: 'manual' }, io);
+      await check({ preset: 'standard', staged: true, projectPath: dir, trigger: 'manual', stateIO }, io);
 
       expect(io.outText()).not.toContain('记录已足够');
       expect(io.outText()).not.toContain('────────────────');

package/src/cli/commands/__tests__/command-gate-dead-options.test.ts

@@ -0,0 +1,60 @@
+/**
+ * command 门禁的两个死配置位已删除（#135，架构评审候选 6）
+ *
+ * `CommandGateConfig.strict` 只在构造时读一次、任何判定路径从不使用——`harness command --strict`
+ * 与不带它判定完全一致；`CommandGateConfig.customBlacklist` 全仓零生产注入者，运行时扩展点是
+ * `addRule()`。triage 裁决两项都**删**（判据同 ADR-0018/0022：不接进判定、不留「配了不生效」），
+ * CLI `--strict` 旗帜随之 removal（属 breaking，见 ADR-0024）。
+ *
+ * 手法照 `passes-gate-dead-options.test.ts` / `init-dead-options.test.ts`：编译期
+ * `@ts-expect-error` 钉字段不存在 + 运行期钉定义表旗帜面与配置形状。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { GATE_DEFINITIONS } from '../../../gates/definitions';
+import { CommandGate } from '../../../gates/command';
+import type { CommandGateConfig } from '../../../gates/types';
+import type { CommandCheckOptions } from '../command';
+
+const commandGateCli = GATE_DEFINITIONS.find(gate => gate.id === 'command')!.cli;
+
+describe('command 门禁的 strict / customBlacklist 已删除（#135）', () => {
+  it('定义表已注册 command 门禁（前提）', () => {
+    expect(commandGateCli).toBeDefined();
+  });
+
+  it('command 旗帜面逐字冻结，不含 --strict', () => {
+    expect(commandGateCli.options.map(option => option.flags)).toEqual([
+      '-l, --level',
+      '--list',
+      '--json',
+    ]);
+  });
+
+  it('CommandGateConfig 与 CommandCheckOptions 的 strict / customBlacklist 已从类型面消失（编译期钉）', () => {
+    // @ts-expect-error strict 零消费者（只在构造时读取），随 #135 从 CommandGateConfig 删除
+    const removedStrict: CommandGateConfig = { strict: true };
+    // @ts-expect-error customBlacklist 零生产注入者，运行时扩展点是 addRule()，随 #135 删除
+    const removedCustom: CommandGateConfig = { customBlacklist: [] };
+    // @ts-expect-error CLI 同名字段随 --strict 旗帜与装配一并删除
+    const removedOption: CommandCheckOptions = { strict: true };
+    expect([removedStrict, removedCustom, removedOption]).toHaveLength(3);
+  });
+
+  it('活字段仍可赋值（防止删多）', () => {
+    const live: CommandGateConfig = { ignoreCategories: ['database'] };
+    const liveCli: CommandCheckOptions = { level: true, list: true, json: false };
+    expect(Object.keys(live)).toHaveLength(1);
+    expect(Object.keys(liveCli)).toHaveLength(3);
+  });
+
+  it('配置读取面只剩 ignoreCategories（运行期形状钉）', () => {
+    expect(Object.keys(new CommandGate().getConfig())).toEqual(['ignoreCategories']);
+  });
+
+  it('CLI 装配点不再引用模块级单例出口（--level 与默认分支同一实例来源）', () => {
+    const cliSource = fs.readFileSync(path.join(__dirname, '..', 'command.ts'), 'utf-8');
+    expect(cliSource).not.toMatch(/getCommandRiskLevel|getCommandGate\(/);
+  });
+});

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

@@ -6,12 +6,12 @@
  */
 
 import { executeCommand } from '../command';
-import { createCommandGate, getCommandRiskLevel } from '../../../gates';
+import { createCommandGate } from '../../../gates';
 import { captureIO, type CapturingIO } from '../../command-contract';
+import { decide, fakeGate } from './gate-decision';
 
 jest.mock('../../../gates', () => ({
   createCommandGate: jest.fn(),
-  getCommandRiskLevel: jest.fn(),
   DEFAULT_COMMAND_BLACKLIST: [
     { id: 'rule-1', level: 'block', message: 'No rm -rf', category: 'destructive', pattern: 'rm -rf' },
     { id: 'rule-2', level: 'warn', message: 'No DROP TABLE', category: 'database', pattern: 'DROP TABLE' },
@@ -27,10 +27,21 @@ jest.mock('chalk', () => ({
 }));
 
 const mockCreateGate = createCommandGate as jest.MockedFunction<typeof createCommandGate>;
-const mockGetRisk = getCommandRiskLevel as jest.MockedFunction<typeof getCommandRiskLevel>;
 
-function mockGate(check: jest.Mock): void {
-  mockCreateGate.mockReturnValue({ check } as any);
+/**
+ * 替身工厂：命令穿过统一接口，替身产决策而非裸报告。
+ * `--level` 与默认分支共用这一台实例（#135），故等级也从替身上取。
+ */
+function mockGate(
+  report: { passed: boolean; message: string; details?: Record<string, any> },
+  level: 'high' | 'medium' | 'low' = 'low',
+): { evaluate: jest.Mock; getRiskLevel: jest.Mock } {
+  const gate = {
+    ...fakeGate(decide('command', report.passed, report.message, report.details)),
+    getRiskLevel: jest.fn().mockReturnValue(level),
+  };
+  mockCreateGate.mockReturnValue(gate as any);
+  return gate;
 }
 
 /** 从捕获输出里取第一条可解析为该形状的 JSON 行 */
@@ -86,7 +97,7 @@ describe('command command', () => {
 
   describe('default mode', () => {
     it('放行：ok，打印 ✓', async () => {
-      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
+      mockGate({ passed: true, message: 'OK' });
 
       const result = await executeCommand('safe-cmd', {}, io);
 
@@ -95,7 +106,7 @@ describe('command command', () => {
     });
 
     it('拒绝：fail + 裁决原因，打印 ✗', async () => {
-      mockGate(jest.fn().mockResolvedValue({ passed: false, message: 'Blocked' }));
+      mockGate({ passed: false, message: 'Blocked' });
 
       const result = await executeCommand('rm -rf /', {}, io);
 
@@ -104,7 +115,7 @@ describe('command command', () => {
     });
 
     it('--json 输出裁决详情', async () => {
-      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK', details: {} }));
+      mockGate({ passed: true, message: 'OK', details: {} });
 
       await executeCommand('cmd', { json: true }, io);
 
@@ -119,8 +130,7 @@ describe('command command', () => {
 
   describe('--level', () => {
     it('low：ok，打印等级', async () => {
-      mockGetRisk.mockReturnValue('low');
-      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
+      mockGate({ passed: true, message: 'OK' }, 'low');
 
       const result = await executeCommand('safe-cmd', { level: true }, io);
 
@@ -129,8 +139,7 @@ describe('command command', () => {
     });
 
     it('high：fail + 等级原因（严重级条件式译成 kind）', async () => {
-      mockGetRisk.mockReturnValue('high');
-      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
+      mockGate({ passed: true, message: 'OK' }, 'high');
 
       const result = await executeCommand('rm -rf /', { level: true }, io);
 
@@ -138,9 +147,7 @@ describe('command command', () => {
     });
 
     it('high 等级不再执行黑名单裁决分支', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'OK' });
-      mockGetRisk.mockReturnValue('high');
-      mockGate(mockCheck);
+      mockGate({ passed: true, message: 'OK' }, 'high');
 
       const result = await executeCommand('rm -rf /', { level: true }, io);
 
@@ -150,8 +157,7 @@ describe('command command', () => {
     });
 
     it('--json 输出等级', async () => {
-      mockGetRisk.mockReturnValue('medium');
-      mockGate(jest.fn().mockResolvedValue({ passed: true, message: 'OK' }));
+      mockGate({ passed: true, message: 'OK' }, 'medium');
 
       await executeCommand('cmd', { level: true, json: true }, io);
 
@@ -160,5 +166,15 @@ describe('command command', () => {
         command: 'cmd',
       });
     });
+
+    it('#135：等级取自本命令创建的那台实例，全程只创建一次', async () => {
+      const gate = mockGate({ passed: false, message: 'Blocked' }, 'high');
+
+      const result = await executeCommand('danger-cmd', { level: true }, io);
+
+      expect(gate.getRiskLevel).toHaveBeenCalledWith('danger-cmd');
+      expect(mockCreateGate).toHaveBeenCalledTimes(1);
+      expect(result).toEqual({ kind: 'fail', reason: expect.stringContaining('risk level is high') });
+    });
   });
 });

package/src/cli/commands/__tests__/constraints-retire.test.ts

@@ -313,6 +313,58 @@ describe('retireConstraint 执行逻辑', () => {
   });
 });
 
+describe('落盘字节与装载次数冻结（harness#137）', () => {
+  /**
+   * YAML 读-改-写两段合并成 `setYamlEntry` 属内部重构：对外产物逐字不得漂移
+   * （票验收 6）。故此处钉的是**字节**而非 yaml.load 后的对象——键序、缩进、
+   * 行宽 120 的折叠口径、注释丢弃后的形态都在断言范围内。
+   */
+  it('内置退役落 config.yml：逐字节冻结', () => {
+    const root = createProjectFixture({
+      name: 'harness-retire-test',
+      config: '# 项目配置\npreset: standard\nscenes:\n  - llm-app\n',
+    });
+
+    retireConstraint(root, 'capability_sync', { reason: '逐字节冻结', now: FIXED_NOW });
+
+    expect(fs.readFileSync(path.join(root, '.harness', 'config.yml'), 'utf-8')).toBe(
+      'preset: standard\nscenes:\n  - llm-app\nconstraints:\n  capability_sync:\n    enabled: false\n' +
+        "    retired:\n      at: '2026-08-08T12:00:00.000Z'\n      reason: 逐字节冻结\n" +
+        '      stats:\n        total: 0\n        fail: 0\n        failRate: 0\n'
+    );
+  });
+
+  it('custom 退役落 custom-constraints.yml：逐字节冻结（规则原文保留、retired 段追加在末尾）', () => {
+    const root = createProjectFixture({ name: 'harness-retire-test' });
+    writeCustom(root, `# 自定义约束\n${CUSTOM_YML}`);
+
+    retireConstraint(root, 'my_custom_rule', { reason: '逐字节冻结', now: FIXED_NOW });
+
+    expect(fs.readFileSync(path.join(root, '.harness', 'custom-constraints.yml'), 'utf-8')).toBe(
+      'custom_constraints:\n  my_custom_rule:\n    level: iron_law\n    rule: 禁止引入 X\n' +
+        '    message: X 已由平台能力替代\n    promptInjection: 禁止引入 X\n' +
+        "    retired:\n      at: '2026-08-08T12:00:00.000Z'\n      reason: 逐字节冻结\n" +
+        '      stats:\n        total: 0\n        fail: 0\n        failRate: 0\n'
+    );
+  });
+
+  it('一次 retireConstraint 只装载一次项目配置（此前 custom 路径走 3 次 load）', async () => {
+    const { ProjectConfigLoader } = await import('../../../core/project-config-loader');
+    const loadSpy = jest.spyOn(ProjectConfigLoader.prototype, 'load');
+    const root = createProjectFixture({ name: 'harness-retire-test' });
+    writeCustom(root, CUSTOM_YML);
+    loadSpy.mockClear();
+
+    retireConstraint(root, 'my_custom_rule', { now: FIXED_NOW });
+    expect(loadSpy).toHaveBeenCalledTimes(1);
+
+    loadSpy.mockClear();
+    retireConstraint(root, 'my_custom_rule', { now: new Date('2026-08-09T00:00:00.000Z') });
+    expect(loadSpy).toHaveBeenCalledTimes(1);
+    loadSpy.mockRestore();
+  });
+});
+
 describe('constraintsRetire 非交互直达', () => {
   it('无 --yes 直达：报错 + 非零退出码 + 不落盘任何文件（#24 人确认闸门）', async () => {
     const root = createProjectFixture({ name: 'harness-retire-test' });