@dommaker/harness 1.6.0 → 1.8.0

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

@@ -4,6 +4,7 @@
 
 import { acceptance, listAcceptanceCriteria } from '../acceptance';
 import { captureIO, type CapturingIO } from '../../command-contract';
+import { decide, fakeGate, throwingGate } from './gate-decision';
 import * as fs from 'fs/promises';
 import { SpecAcceptanceGate } from '../../../gates/acceptance';
 
@@ -14,7 +15,7 @@ jest.mock('fs/promises', () => ({
 
 jest.mock('../../../gates/acceptance', () => ({
   SpecAcceptanceGate: jest.fn().mockImplementation(() => ({
-    check: jest.fn(),
+    evaluate: jest.fn(),
   })),
 }));
 
@@ -46,30 +47,31 @@ describe('acceptance command', () => {
 
   describe('acceptance', () => {
     it('should print success when check passes', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({
-        passed: true,
-        message: 'ok',
-        details: { checkedCriteria: 5, totalCriteria: 5 },
-      });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      MockGate.mockImplementation(() =>
+        fakeGate(decide('acceptance', true, 'ok', { checkedCriteria: 5, totalCriteria: 5 })) as any
+      );
 
       const result = await acceptance({}, io);
 
       expect(io.outText()).toContain('验收标准检查通过');
+      expect(io.outText()).toContain('   通过项: 5');
+      expect(io.outText()).toContain('   总项数: 5');
       expect(result.kind).toBe('ok');
     });
 
     it('should print failure and exit 1 when check fails', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({
-        passed: false,
-        message: 'criteria not met',
-        details: { uncheckedCriteria: ['criteria-1', 'criteria-2'] },
-      });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      MockGate.mockImplementation(() =>
+        fakeGate(
+          decide('acceptance', false, 'criteria not met', {
+            uncheckedCriteria: ['criteria-1', 'criteria-2'],
+          })
+        ) as any
+      );
 
       const result = await acceptance({}, io);
 
       expect(io.outText()).toContain('验收标准检查失败');
+      expect(io.outText()).toContain('   - criteria-1');
       expect(result).toEqual({
         kind: 'fail',
         reason: 'acceptance gate denied: criteria not met',
@@ -77,8 +79,7 @@ describe('acceptance command', () => {
     });
 
     it('should handle errors and exit 1', async () => {
-      const mockCheck = jest.fn().mockRejectedValue(new Error('gate error'));
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      MockGate.mockImplementation(() => throwingGate(new Error('gate error')) as any);
 
       const result = await acceptance({}, io);
 
@@ -90,30 +91,29 @@ describe('acceptance command', () => {
     });
 
     it('should use cwd as default projectPath', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      const gate = fakeGate(decide('acceptance', true, 'ok'));
+      MockGate.mockImplementation(() => gate as any);
 
       await acceptance({}, io);
 
-      expect(mockCheck).toHaveBeenCalledWith(
+      expect(gate.evaluate).toHaveBeenCalledWith(
         expect.objectContaining({ projectPath: process.cwd() }),
       );
     });
 
     it('should pass taskId to gate', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      const gate = fakeGate(decide('acceptance', true, 'ok'));
+      MockGate.mockImplementation(() => gate as any);
 
       await acceptance({ taskId: 'TASK-001' }, io);
 
-      expect(mockCheck).toHaveBeenCalledWith(
+      expect(gate.evaluate).toHaveBeenCalledWith(
         expect.objectContaining({ taskId: 'TASK-001' }),
       );
     });
 
     it('should set e2eTestCommand when runE2e is true', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      MockGate.mockImplementation(() => fakeGate(decide('acceptance', true, 'ok')) as any);
 
       await acceptance({ runE2e: true }, io);
 
@@ -123,8 +123,7 @@ describe('acceptance command', () => {
     });
 
     it('should not set e2eTestCommand when runE2e is false', async () => {
-      const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-      MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
+      MockGate.mockImplementation(() => fakeGate(decide('acceptance', true, 'ok')) as any);
 
       await acceptance({}, io);
 

package/src/cli/commands/__tests__/bin-exit-mapping.test.ts

@@ -10,6 +10,7 @@
  */
 
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import { spawnSync } from 'child_process';
 
@@ -104,4 +105,18 @@ smoke('端到端：真实命令经 bin 映射后的对外退出码', () => {
     expect(r.status).toBe(1);
     expect(r.stderr).toContain('未知子命令: bogus');
   });
+
+  // harness#152：数值旗帜的脏输入此前静默 NaN 穿透（退出码 0、少一道判定），现 fail-loud
+  it('audit 脏阈值 → 1（返回 usage-error，stdout 不出报告）', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-k152-bin-'));
+    try {
+      const r = run(['kb', 'audit', '--dir', dir, '--threshold', 'abc']);
+      expect(r.status).toBe(1);
+      expect(r.stderr).toContain('阈值');
+      expect(r.stdout).not.toContain('阈值 NaN');
+      expect(r.stdout).toBe('');
+    } finally {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
 });

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

@@ -22,8 +22,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() };
+  }),
 }));
 
 jest.mock('../../../utils/exec', () => ({
@@ -114,4 +117,42 @@ describe('check 命令注入漂移警告', () => {
     expect(outputText()).not.toContain('注入漂移');
     expect(result.kind).toBe('ok');
   });
+
+  // ── 生效集来源与漂移比对的同一性（ADR-0023 步骤 4.5）──────────────────
+  // 改前 CLI 给 -p 塞了缺省值 'standard'，「没传」与「传了」不可区分，
+  // 于是「--preset 仅在无自定义配置时覆盖」这条规则恒被触发：项目 config.yml 的
+  // preset 静默失效，而漂移侧按 config.yml 算 → 两边稳定对不上（该报的漂移不报）。
+
+  it('config.yml 的 preset 不再被 CLI 缺省顶掉：不带 -p 按 relaxed 执法且零漂移', async () => {
+    const root = createProjectFixture({
+      name: 'harness-check-drift-relaxed',
+      config: 'preset: relaxed\n',
+    });
+    writeClaudeMd(root, REAL_VERSION); // getEffectiveConstraints(root) 走 config.yml = relaxed
+
+    const result = await check({ staged: false, projectPath: root }, io);
+
+    // relaxed 裁掉的内置条目会出现在「已禁用约束」行——改前 CLI 塞了 standard，这行根本不出现
+    const output = outputText();
+    expect(output).toContain('已禁用约束:');
+    expect(output).not.toContain('内容漂移');
+    expect(output).toContain('约束检查通过');
+    expect(result.kind).toBe('ok');
+  });
+
+  it('显式 -p 时，漂移比对用的就是本 run 实际执法的那份', async () => {
+    const root = createProjectFixture({
+      name: 'harness-check-drift-override',
+      config: 'preset: relaxed\n',
+    });
+    writeClaudeMd(root, REAL_VERSION); // 段里是 relaxed 的少数条目
+
+    await check({ preset: 'standard', staged: false, projectPath: root }, io);
+
+    // standard 不裁条目（无「已禁用约束」行），且期望段 = 本 run 执法的 standard
+    // → 段里条目只少不多，报「缺失 N 条 / 多余 0 条」
+    const output = outputText();
+    expect(output).not.toContain('已禁用约束:');
+    expect(output).toMatch(/内容漂移: 缺失 [1-9]\d* 条 \/ 多余 0 条/);
+  });
 });

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

@@ -0,0 +1,167 @@
+/**
+ * 一次 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');
+  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],
+        // —— 已知例外（改动需明写理由）——
+        // 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,7 @@ import { execFileSync } from 'child_process';
 
 import { check, listLaws } from '../check';
 import { captureIO, type CapturingIO } from '../../command-contract';
-import { configureTraceCollector } from '../../../monitoring/traces';
+import { DEFAULT_TRACE_FILE } from '../../../types/trace';
 import {
   createGitEvidence,
   realGitCommandRunner,
@@ -75,6 +75,23 @@ 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));
+}
+
 /** 计数 git 证据：既记录证据方法请求，也记录实际 spawn 的 git 命令（执行走真 adapter） */
 function recordingEvidence(projectPath: string): {
   evidence: GitEvidence;
@@ -118,28 +135,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 +238,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 +269,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 +317,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 +373,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'])

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\(/);
+  });
+});