@dommaker/harness 1.7.0 → 1.8.1

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

@@ -0,0 +1,192 @@
+/**
+ * sync-docs 的 .ts 内容读取计数闸（#147 B 票，母票 #140「verifier 自己找文件」之二）
+ *
+ * 形状照 `check-read-count.test.ts` / `spec-baseline-read-count.test.ts`：真执行、
+ * 只在中间记一笔，不改任何行为。数的是**底层文件内容读取发生了几次**。
+ *
+ * 本票的承诺面 = **capability-listing 格式下模块清单无人消费，一份 `.ts` 内容都不读**
+ * （改造前：入口无条件全树扫描，逐文件 `await readFile` 只为首行注释）。
+ * 反证用同一棵源码树换成 file-table 格式：描述照旧提取，每份文件一次运行内恰读一次。
+ *
+ * 夹具一律不放 CONTEXT.md：CONTEXT 侧的 `.ts` 读取属导出面采集（#142），不在本票范围，
+ * 放进来会把「扫描分支零内容读」这条闸洗成模糊口径。
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { syncDocs } from '../sync-docs';
+import { captureIO, type CapturingIO } from '../../command-contract';
+
+type ReadCall = { file: string; via: 'readFile' | 'readFileSync' };
+
+// 计数器挂在 globalThis：jest.mock 工厂会被提前调用，闭包外提会撞 TDZ
+jest.mock('fs/promises', () => {
+  const actual = jest.requireActual<typeof import('fs/promises')>('fs/promises');
+  const g = globalThis as unknown as { __SD147_READS__?: ReadCall[] };
+  if (!g.__SD147_READS__) g.__SD147_READS__ = [];
+  const bucket = g.__SD147_READS__;
+  const name = (p: unknown): string => (Buffer.isBuffer(p) ? p.toString('utf8') : String(p));
+
+  return {
+    ...actual,
+    readFile: jest.fn((p: unknown, ...rest: unknown[]) => {
+      bucket.push({ file: name(p), via: 'readFile' });
+      return actual.readFile(p as fs.PathLike, ...(rest as [BufferEncoding])) as Promise<string>;
+    }),
+  };
+});
+
+jest.mock('fs', () => {
+  const actual = jest.requireActual<typeof import('fs')>('fs');
+  const g = globalThis as unknown as { __SD147_READS__?: ReadCall[] };
+  if (!g.__SD147_READS__) g.__SD147_READS__ = [];
+  const bucket = g.__SD147_READS__;
+  const name = (p: unknown): string => (Buffer.isBuffer(p) ? p.toString('utf8') : String(p));
+
+  return {
+    ...actual,
+    readFileSync: jest.fn((p: unknown, ...rest: unknown[]) => {
+      bucket.push({ file: name(p), via: 'readFileSync' });
+      return (actual.readFileSync as unknown as (path: unknown, options?: unknown) => unknown)(
+        p,
+        ...rest
+      );
+    }),
+  };
+});
+
+const reads = () =>
+  ((globalThis as unknown as { __SD147_READS__?: ReadCall[] }).__SD147_READS__ ||= []);
+
+const SOURCE_FILES = [
+  'src/alpha.ts',
+  'src/beta.tsx',
+  'src/nested/gamma.ts',
+  'src/nested/deep/delta.ts',
+];
+
+/** 清单格式与文件表格式共用的源码树（含三处必须被跳过口径排除的同名内容） */
+function fixtureProject(capabilities: 'listing' | 'table' | 'absent'): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sd147-read-count-'));
+  const write = (rel: string, content: string): void => {
+    const target = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, content, 'utf-8');
+  };
+
+  write('src/alpha.ts', '// alpha 的描述\nexport const a = 1;\n');
+  write('src/beta.tsx', 'export const b = 1;\n');
+  write('src/nested/gamma.ts', '/**\n * gamma 的描述\n */\nexport const c = 1;\n');
+  write('src/nested/deep/delta.ts', 'export const d = 1;\n');
+  // 跳过口径的三份对照：barrel、.d.ts、__tests__（外加 node_modules 与 dist）
+  write('src/index.ts', 'export * from "./alpha";\n');
+  write('src/ambient.d.ts', 'export const t = 1;\n');
+  write('src/__tests__/alpha.test.ts', '// 不该被读\nexport const x = 1;\n');
+  write('src/node_modules/pkg/index.ts', '// 不该被读\n');
+  write('src/dist/built.ts', '// 不该被读\n');
+
+  if (capabilities === 'listing') {
+    write(
+      'CAPABILITIES.md',
+      '# Harness Capabilities\n\n## CLI Commands (21)\ncheck, validate, sync-docs\n'
+    );
+  } else if (capabilities === 'table') {
+    write(
+      'CAPABILITIES.md',
+      [
+        '# Harness Capabilities',
+        '',
+        '| 模块 | 文件 | 说明 |',
+        '|------|------|------|',
+        '| alpha | src/alpha.ts | alpha 的描述 |',
+        '',
+      ].join('\n')
+    );
+  }
+  return dir;
+}
+
+const isTsContent = (rel: string): boolean => /\.tsx?$/.test(rel) && !rel.endsWith('.d.ts');
+
+describe('sync-docs 的 .ts 内容读取计数闸（#147）', () => {
+  let io: CapturingIO;
+  let dir: string;
+
+  /** 相对项目根的落点 → 内容读取次数（readFileSync 与异步 readFile 各算一次） */
+  function contentCounts(): 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;
+  }
+
+  function tsContentReads(): Array<[string, number]> {
+    return [...contentCounts().entries()].filter(([rel]) => isTsContent(rel)).sort();
+  }
+
+  beforeEach(() => {
+    // 原地清空：mock 工厂在装载时就 captured 了这个数组引用，换新数组计数会落到旧的去向（假绿）
+    reads().length = 0;
+    io = captureIO();
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('capability-listing 模式：模块清单无人消费 → 一份 .ts 内容都不读', async () => {
+    dir = fixtureProject('listing');
+
+    await syncDocs({ projectPath: dir, check: true, json: true }, io);
+
+    // 正对照：真走了 listing 分支（否则下面的 0 是空跑出来的）
+    expect(JSON.parse(io.outText()).format).toBe('capability-listing');
+    expect(tsContentReads()).toEqual([]);
+  });
+
+  it('反证：file-table 格式照旧逐文件取描述，且每份文件一次运行内恰读一次', async () => {
+    dir = fixtureProject('table');
+
+    await syncDocs({ projectPath: dir, check: true, json: true }, io);
+
+    // 正对照：走了 file-table 分支，描述确实进了对外 JSON（判定面未被这次改造削掉）
+    const json = JSON.parse(io.outText());
+    expect(json.format).toBe('file-table');
+    const described = json.added.map(
+      (a: { module: { file: string; description: string } }) => `${a.module.file}#${a.module.description}`
+    );
+    expect(described.sort()).toEqual([
+      'src/beta.tsx#beta',
+      'src/nested/deep/delta.ts#delta',
+      'src/nested/gamma.ts#gamma 的描述',
+    ]);
+
+    expect(tsContentReads()).toEqual(
+      SOURCE_FILES.map((f) => [f, 1]).sort()
+    );
+  });
+
+  it('CAPABILITIES.md 缺席时同样走 file-table 分支：读取表只含源码清单那几份文件', async () => {
+    dir = fixtureProject('absent');
+
+    await syncDocs({ projectPath: dir, check: true, json: true }, io);
+
+    expect(JSON.parse(io.outText()).format).toBe('file-table');
+    expect(tsContentReads()).toEqual(SOURCE_FILES.map((f) => [f, 1]).sort());
+  });
+
+  it('listing 模式的整张读取表冻结：本次运行只碰 CAPABILITIES.md，源码树零读取', async () => {
+    dir = fixtureProject('listing');
+
+    await syncDocs({ projectPath: dir, check: true, json: true }, io);
+
+    expect([...contentCounts().entries()].sort()).toEqual([['CAPABILITIES.md', 5]]);
+    // CAPABILITIES.md = 5 是**本票范围外的既有重复读**：入口一次异步读 + 计数核对
+    // （checkCapabilityCounts → FreshnessRunner 每条计数规则各读一次）。此处如实冻结，
+    // 既不为它改动也不放行——数字变了就是扫描分支被改动的信号（登记在 #147 resolution）。
+  });
+});

package/src/cli/commands/__tests__/sync-docs.test.ts

@@ -5,6 +5,7 @@
 import * as fs from 'fs';
 import { captureIO, type CapturingIO } from '../../command-contract';
 import * as path from 'path';
+import * as os from 'os';
 import { syncDocs } from '../sync-docs';
 
 let io: CapturingIO;
@@ -13,10 +14,10 @@ beforeEach(() => {
 });
 
 describe('sync-docs command', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-sync-docs');
+  let tempDir: string;
 
   beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-sync-docs-'));
   });
 
   afterAll(() => {

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

@@ -2,7 +2,7 @@
  * validate 命令测试
  */
 
-import { validate, createExampleCheckpoint, createExampleResolutions } from '../validate';
+import { validate } from '../validate';
 import { captureIO, type CapturingIO } from '../../command-contract';
 import * as fs from 'fs/promises';
 import { CheckpointValidator } from '../../../core/validators/checkpoint';
@@ -126,51 +126,4 @@ describe('validate command', () => {
       expect(result).toEqual({ kind: 'fail', reason: '1 个检查点未通过: test-1' });
     });
   });
-
-  describe('createExampleCheckpoint', () => {
-    it('应该创建示例检查点文件', async () => {
-      mockFs.access.mockRejectedValue(new Error('ENOENT'));
-      mockFs.mkdir.mockResolvedValue(undefined);
-      mockFs.writeFile.mockResolvedValue(undefined);
-      mockYaml.dump.mockReturnValue('yaml content');
-
-      await createExampleCheckpoint('/project', io);
-      
-      expect(mockFs.mkdir).toHaveBeenCalled();
-      expect(mockFs.writeFile).toHaveBeenCalled();
-      expect(io.outText()).toContain('已创建示例检查点');
-    });
-
-    it('已存在时不覆盖', async () => {
-      mockFs.access.mockResolvedValue(undefined);
-
-      await createExampleCheckpoint('/project', io);
-
-      expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(io.outText()).toContain('checkpoints.yml 已存在，跳过');
-    });
-  });
-
-  describe('createExampleResolutions', () => {
-    it('应该创建 Resolutions 文件', async () => {
-      mockFs.access.mockRejectedValue(new Error('ENOENT'));
-      mockFs.mkdir.mockResolvedValue(undefined);
-      mockFs.writeFile.mockResolvedValue(undefined);
-
-      await createExampleResolutions('/project', io);
-
-      expect(mockFs.mkdir).toHaveBeenCalled();
-      expect(mockFs.writeFile).toHaveBeenCalled();
-      expect(io.outText()).toContain('已创建 Resolutions 文件');
-    });
-
-    it('已存在时不覆盖', async () => {
-      mockFs.access.mockResolvedValue(undefined);
-
-      await createExampleResolutions('/project', io);
-
-      expect(mockFs.writeFile).not.toHaveBeenCalled();
-      expect(io.outText()).toContain('resolutions.json 已存在，跳过');
-    });
-  });
 });

package/src/cli/commands/acceptance.ts

@@ -9,6 +9,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import { SpecAcceptanceGate } from '../../gates/acceptance';
 import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
+import { reportGateDecision, reportGateError } from '../gate-command';
 
 
 export interface AcceptanceOptions {
@@ -43,38 +44,32 @@ export async function acceptance(
   });
 
   try {
-    // 执行检查
-    const context = {
+    const decision = await gate.evaluate({
       projectPath,
       taskId: options.taskId,
-    };
+    });
 
-    const result = await gate.check(context as any);
-
-    if (result.passed) {
-      log(io);
-      log(io, chalk.green('✅ 验收标准检查通过'));
-      if (result.details) {
-        log(io, chalk.gray(`   通过项: ${result.details.checkedCriteria ?? 0}`));
-        log(io, chalk.gray(`   总项数: ${result.details.totalCriteria ?? 0}`));
-      }
-    } else {
-      log(io);
-      log(io, chalk.red('❌ 验收标准检查失败'));
-      log(io, chalk.red(`   ${result.message}`));
-      if (result.details?.uncheckedCriteria) {
-        (result.details.uncheckedCriteria as string[]).forEach((criteria: string) => {
-          log(io, chalk.red(`   - ${criteria}`));
-        });
-      }
-      return { kind: 'fail', reason: `acceptance gate denied: ${result.message}` };
-    }
-    return { kind: 'ok' };
-  } catch (error: any) {
-    log(io);
-    log(io, chalk.red('❌ 验收标准检查出错'));
-    log(io, chalk.red(`   ${error.message}`));
-    return { kind: 'fail', reason: `acceptance gate error: ${error.message}` };
+    return reportGateDecision(
+      io,
+      {
+        gateId: 'acceptance',
+        label: '验收标准',
+        onPass: (r) =>
+          r.details
+            ? [
+                chalk.gray(`   通过项: ${r.details.checkedCriteria ?? 0}`),
+                chalk.gray(`   总项数: ${r.details.totalCriteria ?? 0}`),
+              ]
+            : [],
+        onFail: (r) =>
+          r.details?.uncheckedCriteria
+            ? (r.details.uncheckedCriteria as string[]).map((criteria: string) => chalk.red(`   - ${criteria}`))
+            : [],
+      },
+      decision
+    );
+  } catch (error) {
+    return reportGateError(io, 'acceptance', '验收标准', error);
   }
 }
 

package/src/cli/commands/check.ts

@@ -5,24 +5,25 @@
  * 工单 23：触发条件与证据检测迁至 core/constraints/context-builder
  * ADR-0001：约束集统一走 getMergedConstraintsConfig 生效集链路（preset/config 禁用/custom/scenes）
  * harness#88：本命令是 trace 记录器的组合根——core 不上行依赖 monitoring，
- * 真实收集器在此经构造参数接线
+ * 真实收集器在此经构造参数接线；#139：收集器锚根构造，trace 落点跟 --project-path 走
  */
 
 import chalk from 'chalk';
-import * as fs from 'fs';
 import * as path from 'path';
 import { ConstraintChecker } from '../../core/constraints/checker';
 import { IRON_LAWS, GUIDELINES, PROMPTS } from '../../core/constraints/definitions';
-import { getMergedConstraintsConfig } from '../../core/effective-constraints';
+import { getMergedConstraintsConfig, constraintsFromMerged } from '../../core/effective-constraints';
 import { buildConstraintContext } from '../../core/constraints/context-builder';
 import { createGitEvidence, type GitEvidence } from '../../core/constraints/git-evidence';
+import { createRunEnv, type RunEnv } from '../../core/constraints/run-env';
 import { detectInjectionDrift } from '../../core/constraints/injection-drift';
 import { GOVERNANCE_HEADING } from '../../core/constraints/injection-writer';
-import { getTraceCollector } from '../../monitoring/traces';
-import { countJsonlLines } from '../../utils/jsonl';
-import { DEFAULT_TRACE_FILE } from '../../types/trace';
+import { TraceCollector } from '../../monitoring/traces';
+import { readJsonl } from '../../utils/jsonl';
+import { DEFAULT_TRACE_FILE, type ExecutionTrace } from '../../types/trace';
 import type { ConstraintResult, ConstraintTrigger } from '../../types/constraint';
 import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
+import { fileStateIO, type StateIO } from '../state-io';
 
 /** 证据行着色（与调用处所属结论块一致） */
 const EVIDENCE_PAINT = {
@@ -51,8 +52,8 @@ function logEvidence(
 }
 
 export interface CheckOptions {
-  /** 预设名称 */
-  preset: string;
+  /** 预设名称；**不传 = 按项目 `.harness/config.yml` 的 preset**（CLI 不给缺省值，见 commands/definitions.ts） */
+  preset?: string;
   /** 是否只检查暂存文件 */
   staged: boolean;
   /** 触发条件 */
@@ -66,6 +67,20 @@ export interface CheckOptions {
    * 测试据此断言"同一 run 内每条 git 命令至多执行一次"。
    */
   evidence?: GitEvidence;
+  /**
+   * 运行级观察面（非 CLI flag；ADR-0023）
+   *
+   * 缺省 = 本 run 独占一份。注入则与调用方共用同一份上行数据读取，
+   * 测试据此断言「同一次运行内同一项目文件至多读一次」。
+   */
+  runEnv?: RunEnv;
+  /**
+   * 状态文件接缝（非 CLI flag；ADR-0026）
+   *
+   * 缺省 = 真实 fs 实现（fileStateIO）。注入则 `.harness/.state.json` 的读写
+   * 走替身，测试据此不碰真文件系统。
+   */
+  stateIO?: StateIO;
 }
 
 /**
@@ -76,15 +91,20 @@ export async function check(
   io: CommandIO = processIO,
 ): Promise<CommandResult> {
   log(io, chalk.blue('🔍 检查约束...'));
-  log(io, chalk.gray(`预设: ${options.preset}`));
+  log(io, chalk.gray(`预设: ${options.preset ?? '（按 config.yml，缺省 standard）'}`));
 
   try {
     const projectPath = options.projectPath || process.cwd();
+    // 一次 run 一份证据与观察面（#87 / ADR-0023）：入口构造，沿生效集、context、checker 向下传
+    const evidence = options.evidence ?? createGitEvidence(projectPath);
+    const runEnv = options.runEnv ?? createRunEnv(projectPath);
+    const stateIO = options.stateIO ?? fileStateIO(projectPath);
 
     // 生效约束集（ADR-0001）：内置 → preset → config.yml 禁用 → custom 追加 → scenes 过滤。
     // --preset 仅在没有项目自定义配置时覆盖 config.yml 的 preset（工单 23 语义：
     // 项目自定义配置优先于 CLI 预设），优先级规则收在 getMergedConstraintsConfig 一处。
-    const merged = getMergedConstraintsConfig(projectPath, { preset: options.preset });
+    // CLI 不给 -p 缺省值：没传 = 尊重 config.yml（ADR-0023 步骤 4.5，缺省值曾让两者不可区分）
+    const merged = getMergedConstraintsConfig(runEnv, { preset: options.preset });
     if (merged.custom.length > 0) {
       log(io, chalk.gray(`自定义约束: ${merged.custom.length} 条`));
     }
@@ -98,12 +118,13 @@ export async function check(
 
     // 构建上下文（工单 23：触发条件与证据检测收敛至 core/constraints/context-builder）
     // #87：一次 run 一份 git 证据——context-builder 与 checker 层共用同一实例
-    const evidence = options.evidence ?? createGitEvidence(projectPath);
+    // ADR-0023：一次 run 一份运行级观察面——配置、源根探测、trace 证据探测全部共用同一份读取
     const context = await buildConstraintContext({
       projectPath: options.projectPath,
       staged: options.staged,
       trigger: options.trigger,
       evidence,
+      runEnv,
     });
     const changedFiles = context.changedFiles ?? [];
     if (changedFiles.length > 0) {
@@ -113,8 +134,9 @@ export async function check(
 
     // 执行三层检查（per-request 传 customConfig，避免单例状态污染；证据同 run 同源）
     // trace 记录器经构造参数接线（harness#88）：一次命令一个 checker 实例
-    const checker = new ConstraintChecker(getTraceCollector());
-    const result = await checker.checkConstraints(context, merged, evidence);
+    // #139：收集器锚根构造——不传 projectPath 时 trace 会落进调用方 cwd，B 侧读不到
+    const checker = new ConstraintChecker(new TraceCollector({ projectPath }));
+    const result = await checker.checkConstraints(context, merged, evidence, runEnv);
 
     // 输出结果
     log(io);
@@ -183,7 +205,8 @@ export async function check(
     // 注入漂移校验（ADR-0001 决策 7）：黄色警告块，不改 exit code、不影响门禁结果。
     // 无漂移/未注入零输出；漂移检测自身异常静默吞掉，绝不影响 check。
     try {
-      const drift = detectInjectionDrift(projectPath);
+      // 生效集直接用本 run 那一份：一遍算完，且比对对象就是本次实际执法的规则集（ADR-0023 步骤 4.5）
+      const drift = detectInjectionDrift(runEnv, undefined, constraintsFromMerged(merged));
       if (drift.hasDrift) {
         log(io);
         log(io, chalk.yellow(`⚠️  检测到 ${drift.injectionFile ?? '治理文档'} 约束注入漂移（仅警告，不阻断）:`));
@@ -206,7 +229,7 @@ export async function check(
     log(io, chalk.green('✅ 约束检查通过'));
 
     // 智能提示
-    const hint = await getSmartHint(projectPath);
+    const hint = await getSmartHint(projectPath, stateIO);
     if (hint) {
       log(io);
       log(io, chalk.gray('────────────────────────────────────'));
@@ -221,44 +244,46 @@ export async function check(
   }
 }
 
+/** 智能提示阈值：trace 累计条数首次达到此数才提示跑 status（判定只要「够不够」，不要总数） */
+const TRACE_HINT_THRESHOLD = 50;
+
 /**
  * 智能提示：检查是否需要提示用户下一步操作
+ *
+ * 状态读写经 StateIO（ADR-0026）：读-改-写，`status` 不再把 `shownHints` 抹掉，
+ * 「首次达到阈值」的去重自此真生效。
  */
-async function getSmartHint(projectPath: string): Promise<string | null> {
+async function getSmartHint(projectPath: string, stateIO: StateIO): Promise<string | null> {
   const tracesPath = path.join(projectPath, DEFAULT_TRACE_FILE);
-  const statePath = path.join(projectPath, '.harness', '.state.json');
 
-  // 只数非空行数（含坏行），零 parse——原语义不变，走 jsonl 正本（harness#82）
-  const traceCount = countJsonlLines(tracesPath);
+  // 只读够 TRACE_HINT_THRESHOLD 行即停（坏行照旧占位，条数口径与改前的纯计数逐字一致）——
+  // traces.log 是 append-only 无上限文件，为一个比较符整读不成立
+  // 计数去向：豁免（harness#100）——本消费面只输出「够不够」的提示行，没有可挂坏行计数的输出位
+  const { records, skippedLines } = readJsonl<ExecutionTrace>(tracesPath, 'skip', {
+    head: TRACE_HINT_THRESHOLD,
+  });
+  const traceCount = records.length + skippedLines;
   if (traceCount === 0) {
     return null;
   }
-  // 读取状态
-  let state: { 
-    shownHints?: string[];
-    lastStatusRun?: string;
-    lastDiagnoseRun?: string;
-  } = {};
-  if (fs.existsSync(statePath)) {
-    state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
-  }
+  // 读取状态（经接缝；文件缺失 → {}）
+  const state = stateIO.read();
   state.shownHints = state.shownHints || [];
-  
+
   const hints: string[] = [];
-  
-  // 条件 1: 记录数首次达到 50
-  if (traceCount >= 50 && !state.shownHints.includes('trace_50')) {
+
+  // 条件 1: 记录数首次达到阈值
+  if (traceCount >= TRACE_HINT_THRESHOLD && !state.shownHints.includes('trace_50')) {
     hints.push('📊 记录已足够，运行 harness status 查看统计');
     state.shownHints.push('trace_50');
   }
 
   // 保存状态
   if (hints.length > 0) {
-    fs.mkdirSync(path.dirname(statePath), { recursive: true });
-    fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    stateIO.write(state);
     return hints.join('\n');
   }
-  
+
   return null;
 }
 

package/src/cli/commands/command.ts

@@ -10,14 +10,14 @@
  * 退出码映射收敛在 bin 一处。
  */
 
-import { createCommandGate, getCommandRiskLevel, DEFAULT_COMMAND_BLACKLIST, type CommandBlacklistRule } from '../../gates';
+import { createCommandGate, DEFAULT_COMMAND_BLACKLIST, type CommandBlacklistRule } from '../../gates';
 import { log, logError, processIO, type CommandIO, type CommandResult } from '../command-contract';
+import { gateCommandResult } from '../gate-command';
 
 export interface CommandCheckOptions {
   level?: boolean;
   list?: boolean;
   json?: boolean;
-  strict?: boolean;
 }
 
 /**
@@ -65,11 +65,14 @@ export async function executeCommand(
     return { kind: 'usage-error', reason: '缺少要检查的命令参数' };
   }
 
-  const gate = createCommandGate({ strict: options.strict });
-  const result = await gate.check(cmd);
+  const gate = createCommandGate();
+  // 命令门禁只判命令串、不读项目根；GateContext 仍要求项目根——本命令无 -p 旗帜，取真实 cwd
+  const decision = await gate.evaluate({ projectPath: process.cwd(), command: cmd });
+  const result = decision.result;
 
   if (options.level) {
-    const level = getCommandRiskLevel(cmd);
+    // 等级取自本命令创建的这台实例：与默认分支同一来源，配置不再中途丢失（#135）
+    const level = gate.getRiskLevel(cmd);
     if (options.json) {
       log(io, JSON.stringify({ level, command: cmd }));
     } else {
@@ -97,7 +100,5 @@ export async function executeCommand(
     log(io, result.passed ? `\x1b[32m✓\x1b[0m ${result.message}` : `\x1b[31m✗\x1b[0m ${result.message}`);
   }
 
-  return result.passed
-    ? { kind: 'ok' }
-    : { kind: 'fail', reason: `command gate denied: ${result.message}` };
+  return gateCommandResult('command', decision);
 }