@dommaker/harness 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dommaker/harness",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "通用工程约束框架 - 铁律系统、检查点验证、测试门控",
   "keywords": [
     "harness",

package/src/__tests__/passes-gate-check.test.ts

@@ -95,12 +95,28 @@ describe('PassesGate.check()', () => {
   });
 
   /**
-   * AC-007：保留原有 setPasses() 方法（向后兼容）
+   * AC-007（ADR-0022 改写）：零消费者方法已从公共面删除
+   *
+   * 原用例断言「保留 setPasses() 向后兼容」——兼容对象经 harness+studio 双仓
+   * 核实不存在，ADR-0022 明确推翻该 AC。`@ts-expect-error` 在编译期钉住删除，
+   * 运行期断言同时钉住形状（方法不存在于原型）。
    */
-  it('AC-007: should keep setPasses() method for backward compatibility', () => {
+  it('AC-007: setPasses()/getTestResult()/checkTestFileChanges() are removed from the public surface', () => {
     const gate = new PassesGate();
-    expect(gate.setPasses).toBeDefined();
-    expect(typeof gate.setPasses).toBe('function');
+
+    // @ts-expect-error setPasses 已随 ADR-0022 删除
+    expect(gate.setPasses).toBeUndefined();
+    // @ts-expect-error getTestResult 已随 ADR-0022 删除
+    expect(gate.getTestResult).toBeUndefined();
+    // @ts-expect-error checkTestFileChanges 已随 ADR-0022 删除
+    expect(gate.checkTestFileChanges).toBeUndefined();
+    expect(PassesGate.prototype).not.toHaveProperty('setPasses');
+    expect(PassesGate.prototype).not.toHaveProperty('getTestResult');
+    expect(PassesGate.prototype).not.toHaveProperty('checkTestFileChanges');
+
+    // 保留面：真实消费的方法不动
+    expect(typeof gate.check).toBe('function');
+    expect(typeof gate.runTests).toBe('function');
   });
 
   /**

package/src/__tests__/passes-gate.test.ts

@@ -33,34 +33,6 @@ describe('PassesGate', () => {
     }
   });
 
-  describe('setPasses', () => {
-    it('设置为 false 应该直接允许', async () => {
-      const result = await gate.setPasses('task-1', false, tempDir);
-      
-      expect(result.allowed).toBe(true);
-      expect(result.testResult?.passed).toBe(false);
-    });
-
-    it('设置为 true 应该运行测试', async () => {
-      const result = await gate.setPasses('task-2', true, tempDir, {
-        id: 'task-2',
-      });
-      
-      // 测试命令是 echo "1 passed"，所以应该通过
-      expect(result.allowed).toBe(true);
-      expect(result.testResult?.command).toContain('npm test');
-    });
-
-    it('禁用时应该允许所有设置', async () => {
-      const disabledGate = createPassesGate({ enabled: false });
-      
-      const result = await disabledGate.setPasses('task-3', true, tempDir);
-      
-      expect(result.allowed).toBe(true);
-      expect(result.attempts).toBe(0);
-    });
-  });
-
   describe('runTests', () => {
     // 执行根由调用方传入（#95）：tempDir 的 package.json 测试命令是 echo，不再跑真实套件
     it('应该返回测试结果', async () => {
@@ -72,15 +44,6 @@ describe('PassesGate', () => {
     });
   });
 
-  describe('detectTestCommand', () => {
-    it('应该检测 npm test', async () => {
-      // package.json 有 test script
-      const result = await gate.setPasses('task-4', true, tempDir);
-      
-      expect(result.testResult?.command).toContain('npm');
-    });
-  });
-
   // 探测正本行为钉住（架构评审 A2：CLI/core 双版收口后的统一语义，
   // 此前 e2e 优先级、echo 排除、兜底均无测试钉住）
   describe('detectTestCommand 正本（统一探测顺序）', () => {
@@ -153,70 +116,13 @@ describe('PassesGate', () => {
       expect(await detectTestCommand(emptyDir)).toBeUndefined();
     });
 
-    it('探测失败时 runTests 与 setPasses 双路径 fail-closed', async () => {
+    it('探测失败时 runTests fail-closed', async () => {
       const emptyDir = join(detectDir, 'fail-closed');
       mkdirSync(emptyDir, { recursive: true });
 
       const runResult = await gate.runTests(emptyDir);
       expect(runResult.passed).toBe(false);
       expect(runResult.message).toBe('未检测到测试命令');
-
-      const setResult = await gate.setPasses('task-nocmd', true, emptyDir);
-      expect(setResult.allowed).toBe(false);
-      expect(setResult.testResult?.passed).toBe(false);
-      expect(setResult.testResult?.output).toBe('未检测到测试命令');
-    });
-  });
-
-  describe('checkTestFileChanges', () => {
-    it('应该检测测试文件变更', async () => {
-      // 无 git 变更时返回空数组
-      const changes = await gate.checkTestFileChanges(tempDir);
-      
-      expect(Array.isArray(changes)).toBe(true);
-    });
-  });
-
-  describe('getTestResult', () => {
-    it('应该返回已存储的测试结果', async () => {
-      const result = await gate.setPasses('stored-task', true, tempDir);
-      
-      if (result.allowed && result.testResult) {
-        const stored = gate.getTestResult('stored-task');
-        expect(stored).toBeDefined();
-        expect(stored?.command).toContain('npm');
-      }
-    });
-
-    it('未存储任务应返回 undefined', () => {
-      const stored = gate.getTestResult('nonexistent-task');
-      expect(stored).toBeUndefined();
-    });
-  });
-
-  describe('测试失败重试', () => {
-    it('测试失败后应重试', async () => {
-      const retryDir = join(process.cwd(), 'temp-test-retry');
-      mkdirSync(retryDir, { recursive: true });
-      
-      writeFileSync(join(retryDir, 'package.json'), JSON.stringify({
-        name: 'retry-project',
-        scripts: { test: 'exit 1' },  // 总是失败
-      }));
-      
-      const retryGate = createPassesGate({
-        enabled: true,
-        maxRetries: 1,
-        retryDelay: 100,
-      });
-      
-      const result = await retryGate.setPasses('retry-task', true, retryDir);
-      
-      expect(result.allowed).toBe(false);
-      expect(result.attempts).toBeGreaterThan(1);
-      expect(result.error).toBeDefined();
-      
-      rmSync(retryDir, { recursive: true, force: true });
     });
   });
 
@@ -237,13 +143,13 @@ describe('PassesGate', () => {
       },
     });
 
-    it('setPasses 结果不带 coverage 字段', async () => {
+    it('runTests 结果不带 coverage 字段', async () => {
       const covGate = createPassesGate({ enabled: true, requireEvidence: false });
 
-      const result = await covGate.setPasses('cov-task', true, covDir);
+      const result = await covGate.runTests(covDir);
 
-      expect(result.testResult?.passed).toBe(true);
-      expect(result.testResult).not.toHaveProperty('coverage');
+      expect(result.passed).toBe(true);
+      expect(result).not.toHaveProperty('coverage');
     });
 
     it('TaskTestResult 公开类型面不再接受 coverage 字段', () => {

package/src/__tests__/performance-gate.test.ts

@@ -38,7 +38,7 @@ describe('PerformanceGate', () => {
       const gate = new PerformanceGate({
         enabled: true,
         thresholds: {
-          maxResponseTime: 1000,
+          maxBundleSize: 1000,
         },
       });
 
@@ -55,20 +55,12 @@ describe('PerformanceGate', () => {
     it('应该支持自定义阈值', () => {
       const gate = new PerformanceGate({
         thresholds: {
-          maxResponseTime: 500,
-          maxMemoryUsage: 1000,
+          minCoverage: 80,
+          maxBundleSize: 1000,
         },
       });
 
       expect(gate).toBeDefined();
     });
-
-    it('应该支持基准测试命令', () => {
-      const gate = new PerformanceGate({
-        benchmarkCommand: 'npm run benchmark',
-      });
-
-      expect(gate).toBeDefined();
-    });
   });
 });

package/src/__tests__/public-exports.test.ts

@@ -5,29 +5,28 @@
  * 改动 src/index.ts 导出清单时同步更新本文件的 EXPECTED_RUNTIME_EXPORTS，
  * diff 即 PR 评审材料。
  *
- * 注意：Object.keys 只能看到运行时（值）导出；纯类型导出由
- * src/index.ts 显式清单在编译期把关，不在本测试断言范围内。
+ * 两个面两道闸：运行时（值）导出由 Object.keys 逐字冻结；纯类型导出在运行时不可见，
+ * 由下方「包根类型面」闸把关——编译期 `@ts-expect-error` 钉已删类型 + 源形状钉整条 barrel 链。
+ * 类型面曾有此空缺时 `PassesGateResult` 漏删未被抓到（review A2），钉子据此补上。
  */
 
+import * as fs from 'fs';
+import * as path from 'path';
+
 const EXPECTED_RUNTIME_EXPORTS = [
-  'AdaptiveTokenBudget',
   'AgentLifecycle',
   'CONSTRAINTS_END_MARKER',
   'CONSTRAINTS_START_MARKER',
   'CSOValidator',
   'CheckCache',
   'CheckpointValidator',
-  'CleanStateManager',
   'ColdStartImporter',
   'CommandGate',
   'ConstraintViolationError',
-  'ConstraintViolationHandler',
   'ContextTracker',
   'ContractGate',
   'DEFAULT_CLASSIFICATION_RULES',
-  'DEFAULT_CODE_CHECKPOINTS',
   'DEFAULT_COMMAND_BLACKLIST',
-  'DEFAULT_COMPACTION_CONFIG',
   'DEFAULT_DECAY_CONFIG',
   'DEFAULT_FAILURE_LOG_FILE',
   'DEFAULT_LEVEL_MAPPING',
@@ -49,10 +48,8 @@ const EXPECTED_RUNTIME_EXPORTS = [
   'KnowledgeIngest',
   'KnowledgeInjector',
   'KnowledgeLifecycle',
-  'KnowledgeLifecycleHooks',
   'KnowledgeLinter',
   'KnowledgeQuery',
-  'MINIMAL_CHECKPOINTS',
   'PHASE_SUBJECT_RE',
   'PROMPTS',
   'PassesGate',
@@ -60,9 +57,7 @@ const EXPECTED_RUNTIME_EXPORTS = [
   'ReferenceTracker',
   'ReviewGate',
   'SecurityGate',
-  'SessionCompaction',
   'SessionManager',
-  'SessionStartup',
   'SpecAcceptanceGate',
   'SpecValidator',
   'TESTED_BY_RE',
@@ -83,7 +78,6 @@ const EXPECTED_RUNTIME_EXPORTS = [
   'configureTraceCollector',
   'createAnalyzer',
   'createCheckerGate',
-  'createCleanStateManager',
   'createCommandGate',
   'createContractGate',
   'createErrorClassifier',
@@ -92,12 +86,8 @@ const EXPECTED_RUNTIME_EXPORTS = [
   'createPerformanceGate',
   'createReviewGate',
   'createSecurityGate',
-  'createSessionStartup',
   'createSpecAcceptanceGate',
   'decisionFromResult',
-  'executeWithBlock',
-  'executeWithCollect',
-  'executeWithSafeBoolean',
   'extractCodeStructure',
   'findConstraintsByTrigger',
   'getAllConstraints',
@@ -139,3 +129,43 @@ describe('公共导出清单（ADR-0003）', () => {
     expect(Object.keys(mod).sort()).toEqual([...EXPECTED_RUNTIME_EXPORTS].sort());
   });
 });
+
+/**
+ * 包根类型面闸（review A2）
+ *
+ * 上一闸的 `Object.keys(mod)` 只看得到运行时（值）导出，类型面历史上无对等闸——
+ * `PassesGateResult`（已删 `setPasses` 的返回形状）正是这样从 #125 的「关联类型导出随迁」
+ * 里漏掉、经四级 barrel 存活为公开类型。手法同 #125 的 AC-007：编译期 `@ts-expect-error`
+ * 钉住删除 + 源形状钉住整条链，活类型正钉防删多。
+ */
+describe('包根类型面（ADR-0022 关联类型随迁）', () => {
+  const BARREL_CHAIN = [
+    '../types/passes-gate.ts',
+    '../core/validators/index.ts',
+    '../core/index.ts',
+    '../index.ts',
+  ];
+
+  it('PassesGateResult 在整条 barrel 链四级都已消失', () => {
+    for (const rel of BARREL_CHAIN) {
+      const source = fs.readFileSync(path.join(__dirname, rel), 'utf-8');
+      expect({ file: rel, mentions: /PassesGateResult/.test(source) }).toEqual({
+        file: rel,
+        mentions: false,
+      });
+    }
+  });
+
+  it('PassesGateResult 不再是包根可导入类型（编译期钉）', () => {
+    // @ts-expect-error 该类型是已删 setPasses 的返回形状，随 ADR-0022 关联类型口径删除
+    const removedType: import('../index').PassesGateResult | undefined = undefined;
+    expect(removedType).toBeUndefined();
+  });
+
+  it('活类型仍可经包根导入（防止删多）', () => {
+    const liveCheck: import('../index').PassesGateCheckResult = { allowed: true };
+    const liveTask: import('../index').TaskTestResult = { passed: true, command: 'npm test' };
+    expect(liveCheck.allowed).toBe(true);
+    expect(liveTask.command).toBe('npm test');
+  });
+});

package/src/__tests__/trace-analyzer.test.ts

@@ -3,11 +3,15 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
-import { TraceAnalyzer } from '../monitoring/trace-analyzer';
+import {
+  TraceAnalyzer,
+  summarizeTraces,
+  detectTraceAnomalies,
+} from '../monitoring/trace-analyzer';
 import { TraceCollector } from '../monitoring/traces';
 import * as fs from 'fs';
 import * as path from 'path';
-import type { ExecutionTrace } from '../types/trace';
+import type { ExecutionTrace, TraceSummary } from '../types/trace';
 
 describe('TraceAnalyzer', () => {
   const tempDir = path.join(process.cwd(), 'temp-test-analyzer');
@@ -127,4 +131,50 @@ describe('TraceAnalyzer', () => {
       expect(customAnalyzer).toBeDefined();
     });
   });
+
+  // ADR-0020：summarize / detectAnomalies 的判定本体住在模块级纯函数上，
+  // 类壳只是转发。下面两枚用例直调模块级函数，钉住这个 interface——
+  // 经类壳的既有覆盖（上文）删不掉它，反之它也不依赖任何 collector/文件 IO。
+  describe('模块级纯函数', () => {
+    it('summarizeTraces 不构造 collector 即可汇总，skip 不进 pass/fail 分母', () => {
+      const traces: ExecutionTrace[] = [
+        { constraintId: 'pure', level: 'iron_law', timestamp: 1000, result: 'pass' },
+        { constraintId: 'pure', level: 'iron_law', timestamp: 2000, result: 'fail' },
+        { constraintId: 'pure', level: 'iron_law', timestamp: 3000, result: 'skip' },
+      ];
+
+      const summaries = summarizeTraces(traces);
+
+      expect(summaries).toHaveLength(1);
+      const summary = summaries[0];
+      expect(summary.constraintId).toBe('pure');
+      expect(summary.totalChecks).toBe(3);
+      expect(summary.skipCount).toBe(1);
+      expect(summary.passRate).toBeCloseTo(0.5);
+      expect(summary.failRate).toBeCloseTo(0.5);
+    });
+
+    it('detectTraceAnomalies 的阈值经参数传入，默认与自定义各判一次', () => {
+      // failRate 6/14 ≈ 0.43 且趋势上升：默认阈值 0.5 不触发，0.3 触发
+      const summary: TraceSummary = {
+        constraintId: 'param_threshold',
+        level: 'iron_law',
+        timeRange: { start: 1000, end: 2400 },
+        totalChecks: 14,
+        passCount: 8,
+        failCount: 6,
+        ignoreCount: 0,
+        passRate: 8 / 14,
+        failRate: 6 / 14,
+        recentTrend: 'rising',
+      };
+
+      expect(detectTraceAnomalies([summary])).toEqual([]);
+
+      const anomalies = detectTraceAnomalies([summary], { thresholds: { failRate: 0.3 } });
+      const rising = anomalies.find(a => a.type === 'rising_fail_rate');
+      expect(rising?.constraintId).toBe('param_threshold');
+      expect(rising?.data.threshold).toBe(0.3);
+    });
+  });
 });

package/src/cli/commands/CONTEXT.md

@@ -1,7 +1,7 @@
 # cli/commands/
 
 ## 职责
-CLI 子命令实现：23 个顶层命令 + constraints 治理子命令 report/retire，覆盖约束检查/门禁验证/文档同步/知识管理/失败诊断/发布/会话分析等。
+CLI 子命令实现：21 个顶层命令 + constraints 治理子命令 report/retire，覆盖约束检查/门禁验证/文档同步/知识管理/失败诊断/发布等。
 
 H5（#44）起：
 - **命令定义即注册**：`definitions.ts` 的 `COMMAND_DEFINITIONS` 是命令形状（名称/别名/位置参数/选项/子命令/实现引用）的单一来源；bin/harness.js 遍历本表注册表驱动生成，不再手写 commander 命令块，不再有 index.ts barrel 两处同步（R6）
@@ -10,7 +10,7 @@ H5（#44）起：
 ## 核心导出
 - `COMMAND_DEFINITIONS`（definitions.ts）— 全部非门禁命令定义（纯数据模块、零闭包，禁止 import 命令实现；ADR-0010）
 - 命令契约（`src/cli/command-contract.ts`，上层目录）— `CommandResult` / `CommandKind` / `CommandIO` / `processIO` / `captureIO` / `lastJsonOutput` / `log` / `logError`
-- 各命令文件：check / validate / passes-gate / init / report / status / spec / sync-docs / knowledge / sdd / failure / posteval-plan / release / analyze-sessions / update-user-model / constraints / spec-baseline-check
+- 各命令文件：check / validate / passes-gate / init / report / status / spec / sync-docs / knowledge / sdd / failure / posteval-plan / release / constraints / spec-baseline-check
 - 6 门禁命令实现在 `acceptance` / `command` / `contract` / `performance` / `review` / `security`（其 CLI 元数据在 `src/gates/definitions.ts`，形状同为 `CommandDefinition`，ADR-0007）
 
 `constraints` 下挂治理子命令：`constraints report`（使用统计 + 退役候选诊断 + 配置健康 + 注入漂移，`--export` 脱敏）、`constraints retire`（交互选择 + 人确认退役；带 id 直达需显式 `--yes`（#24 人确认闸门），无 `--yes` 报错 + 非零退出码且不落盘；内置落 config.yml retired 元数据，custom 落 custom-constraints.yml 条目 retired 段（studio#82 D6 一处真相）+ KnowledgeStore 沉淀 + 治理注入段同步）。
@@ -29,6 +29,7 @@ H5（#44）起：
 - **definitions.ts 是纯数据模块（ADR-0010 后零闭包）**：禁止 import 任何命令实现/运行时依赖（保 --help/--version 懒加载）；子命令别名是数据（条目 `aliases: string[]`，不复印整块），实参编组（缺参闸门/强转/兜底）归各命令模块的具名导出（如 `knowledgeSearchCommand`/`coverageCheck`）；实现引用可解析性由 `__tests__/registry.test.ts` 构建/测试期断言
 - 命令选项类型命名规范：XxxOptions
 - **本层是上行数据的注入方（harness#88）**：core 对 cli/gates/monitoring 零值导入，故 `check`/`report` 自己 `new ConstraintChecker(getTraceCollector())`（组合根接线 trace 记录器；用 `constraintChecker`/`getInstance()` 拿到的默认实例不写 trace），`sync-docs` 把 `COMMAND_DEFINITIONS` + `GATE_DEFINITIONS` 组装成 `CapabilityDefinitionSource` 注入 `capabilities-parser` 供能力清单计数
+- **数据已在手就不再构造带 IO 副作用的实例（ADR-0020）**：`status` 按 projectPath 直读出 traces 后，直调 `monitoring/trace-analyzer` 的模块级纯函数 `summarizeTraces()`/`detectTraceAnomalies()`，不再 `new TraceCollector({traceFile})` + `new TraceAnalyzer(c)`——collector 构造函数带 mkdir 副作用，而这条路径上它的读方法从未被调用，实例纯属构造仪式。机器可检：`__tests__/status-analysis-wiring.test.ts`（源形状闸：命令体不得出现 `new TraceCollector`/`new TraceAnalyzer`，也不 import `monitoring/traces`）
 - **projectPath 只在入口兜底一次，并传到每个 IO/执行点（harness#95）**：`-p/--project-path` 的 cwd 兜底唯一落点是命令模块入口（`const projectPath = options.projectPath || process.cwd()`）；往下每层只能收参数，**禁止再取一次 `process.cwd()`、也禁止用相对路径默认值**——两者都让 `-p` 半失效：执行/读写位置悄悄回到调用方 cwd，而 acceptance 的「无 tasks.yml 即跳过」本身就是 `passed:true`，于是失效表现为假绿。落地形状：执行/IO 根用**必传形参**表达（`PassesGate.runTests(workDir)`），门禁内的相对子路径锚到 projectPath：`ContractGate` 一直是 `path.join(context.projectPath, contractPath)`，`SpecAcceptanceGate` 的 tasksPath 随 #95 对齐成 `path.resolve(projectPath, 相对值)`（绝对值原样，缺省 `<projectPath>/tasks.yml`）
   - 机器可检：`__tests__/project-path-convention.test.ts` 三道闸——CLI 层 cwd 必须是 `xxx || process.cwd()` 兜底形状、下游层（= src 减 cli）cwd 站点**逐行**冻结（#98，豁免文件内新增行/行变形同样失败）、相对路径默认值冻结（#98 收紧：`xxxPath: '相对值'` 对象字面量之外，参数默认值形/模板字面量/双引号形同罪，扫描域 = 整个下游层）；豁免逐条带理由，站点消失却不删条目同样失败
   - 行为可检：`__tests__/project-path-anchoring.test.ts` 前提统一 **cwd ≠ projectPath**、不 mock 任何 IO，断言测试真在 B 执行、证据落 `B/.harness/evidence/`、acceptance 读 `B/tasks.yml`。「根已传入却又取 cwd」这类静态看不出的漂移由它守，冻结表守的是不再新增站点

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

@@ -0,0 +1,70 @@
+/**
+ * passes-gate 重试选项死旗帜闸（code-review A1）
+ *
+ * 重试实现原住 `setPasses`，随 ADR-0022 删除后 `PassesGateConfig.maxRetries` /
+ * `retryDelay` 整条装配链只剩写入方、全仓无读取方——`harness passes-gate
+ * --max-retries N` 是恒不生效选项。ADR-0018 删 performance 幽灵旗帜的判据
+ * （只执法有真实现的维度）据此收口。
+ *
+ * 手法同 #125 的 AC-007：编译期 `@ts-expect-error` 钉字段不存在 + 运行期钉定义表与源形状。
+ * `src/agents/types.ts` 的 `maxRetries` 是 AgentLifecycle 自有字段（`lifecycle.ts` 真读取），
+ * 不在本闸范围内。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { COMMAND_DEFINITIONS } from '../definitions';
+import type { PassesGateConfig } from '../../../types/passes-gate';
+import type { PassesGateOptions } from '../passes-gate';
+
+const passesGateCommand = COMMAND_DEFINITIONS.find(d => d.command === 'passes-gate');
+const cliSource = fs.readFileSync(path.join(__dirname, '..', 'passes-gate.ts'), 'utf-8');
+const validatorSource = fs.readFileSync(
+  path.join(__dirname, '..', '..', '..', 'core', 'validators', 'passes-gate.ts'),
+  'utf-8',
+);
+
+describe('passes-gate 重试选项已删除（A1）', () => {
+  it('定义表已注册 passes-gate（前提）', () => {
+    expect(passesGateCommand).toBeDefined();
+  });
+
+  it('passes-gate 旗帜面逐字冻结，不含 --max-retries', () => {
+    expect((passesGateCommand?.options || []).map(o => o.flags)).toEqual([
+      '-t, --test-command <command>',
+      '-p, --project-path <path>',
+      '--allow-partial',
+      '--coverage',
+      '--coverage-threshold <n>',
+    ]);
+  });
+
+  it('命令定义表任意层级都不含 retry 旗帜（防换个命令位复活）', () => {
+    expect(JSON.stringify(COMMAND_DEFINITIONS)).not.toMatch(/retry/i);
+  });
+
+  it('CLI 装配链与 validator 默认配置都不再写重试字段', () => {
+    expect(cliSource).not.toMatch(/maxRetries|retryDelay/);
+    expect(validatorSource).not.toMatch(/maxRetries|retryDelay/);
+  });
+
+  it('PassesGateConfig / PassesGateOptions 的重试字段已从类型面消失（编译期钉）', () => {
+    // @ts-expect-error maxRetries 只写不读，随 A1 从 PassesGateConfig 删除
+    const removedMaxRetries: PassesGateConfig = { maxRetries: 2 };
+    // @ts-expect-error retryDelay 只写不读，随 A1 从 PassesGateConfig 删除
+    const removedRetryDelay: PassesGateConfig = { retryDelay: 1000 };
+    // @ts-expect-error CLI 侧同名字段随旗帜与装配一并删除
+    const removedOption: PassesGateOptions = { maxRetries: 2 };
+    expect([removedMaxRetries, removedRetryDelay, removedOption]).toHaveLength(3);
+  });
+
+  it('活字段仍可赋值（防止删多）', () => {
+    const live: PassesGateConfig = {
+      enabled: true,
+      testCommand: 'npm test',
+      requireEvidence: false,
+      allowPartialPass: true,
+    };
+    expect(Object.keys(live)).toHaveLength(4);
+  });
+});

package/src/cli/commands/__tests__/passes-gate.test.ts

@@ -130,9 +130,13 @@ describe('passes-gate command', () => {
       }));
 
       await runPassesGate({ testCommand: 'pytest' }, io);
-      expect(MockPassesGate).toHaveBeenCalledWith(
-        expect.objectContaining({ testCommand: 'pytest' })
-      );
+      // 精确形状（A1）：装配面只剩四个活字段，只写不读的重试字段已随旗帜一并删除
+      expect(MockPassesGate).toHaveBeenCalledWith({
+        enabled: true,
+        testCommand: 'pytest',
+        requireEvidence: false,
+        allowPartialPass: false,
+      });
     });
   });
 

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

@@ -35,7 +35,7 @@ describe('performance command', () => {
       passed: true,
       message: 'ok',
       details: {
-        metrics: { coverage: 85.5, bundleSize: 204800, benchmarkTime: 150 },
+        metrics: { coverage: 85.5, bundleSize: 204800 },
       },
     });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
@@ -76,7 +76,7 @@ describe('performance command', () => {
     });
   });
 
-  it('should convert bundleThreshold from KB to bytes', async () => {
+  it('bundleThreshold 直传 KB 到 maxBundleSize（不再按字节错位换算）', async () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
@@ -84,23 +84,12 @@ describe('performance command', () => {
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({
-        thresholds: expect.objectContaining({ bundleSize: 500 * 1024 }),
+        thresholds: expect.objectContaining({ maxBundleSize: 500 }),
       }),
     );
   });
 
-  it('should convert benchmarkTimeout from seconds to ms', async () => {
-    const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
-    MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
-
-    await performance({ benchmarkTimeout: 30 }, io);
-
-    expect(MockGate).toHaveBeenCalledWith(
-      expect.objectContaining({ benchmarkTimeout: 30000 }),
-    );
-  });
-
-  it('should set coverage threshold when both flags provided', async () => {
+  it('coverage 旗帜对齐 minCoverage 字段（原 coverage 错位键名恒不生效）', async () => {
     const mockCheck = jest.fn().mockResolvedValue({ passed: true, message: 'ok' });
     MockGate.mockImplementation(() => ({ check: mockCheck }) as any);
 
@@ -108,7 +97,7 @@ describe('performance command', () => {
 
     expect(MockGate).toHaveBeenCalledWith(
       expect.objectContaining({
-        thresholds: expect.objectContaining({ coverage: 90 }),
+        thresholds: expect.objectContaining({ minCoverage: 90 }),
       }),
     );
   });

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

@@ -4,7 +4,7 @@
  * - 定义表内每个实现引用（module+export）都必须可解析（构建/测试期断言，
  *   取代 commands barrel 的编译期保护——R6 消灭手工同步后的闭环兜底）
  * - definitions 是纯数据模块：require 它不加载任何命令实现（保 --help/--version 懒加载）
- * - 命令面与 CAPABILITIES.md 的 24 顶层命令一致（防误删回归）
+ * - 命令面与 CAPABILITIES.md 的 21 顶层命令一致（防误删回归）
  * - bin/harness.js 端到端冒烟（dist 存在时）：--version/--help 零命令实现模块，
  *   单命令执行只加载该命令模块（O2 per-command 懒加载）
  */
@@ -35,7 +35,7 @@ function collectRefs(defs: CommandDefinition[]): CommandImplRef[] {
 const EXPECTED_TOP_LEVEL_COMMANDS = [
   'check', 'validate', 'passes-gate', 'init', 'report', 'status', 'spec',
   'sync-docs', 'knowledge', 'sdd', 'failure', 'posteval-plan',
-  'update-user-model', 'release', 'analyze-sessions', 'constraints',
+  'release', 'constraints',
   'spec-baseline-check',
   // 6 门禁命令（GATE_DEFINITIONS 驱动）
   'acceptance', 'command', 'contract', 'performance', 'review', 'security',
@@ -88,7 +88,7 @@ describe('命令注册表闭环', () => {
     }
   });
 
-  it('顶层命令面与预期 24 命令一致（含 6 门禁）', () => {
+  it('顶层命令面与预期 21 命令一致（含 6 门禁）', () => {
     const names = [
       ...COMMAND_DEFINITIONS.map(d => d.command.split(' ')[0]),
       ...GATE_DEFINITIONS.map(d => d.cli.command.split(' ')[0]),
@@ -97,6 +97,49 @@ describe('命令注册表闭环', () => {
     expect(names.sort()).toEqual([...EXPECTED_TOP_LEVEL_COMMANDS].sort());
   });
 
+  /**
+   * 文档手抄面根因闸（review A5）
+   *
+   * `CLAUDE.md` 的「N CLI subcommands (…)」与 `cli/commands/CONTEXT.md` 的命令清单/计数
+   * 都是注册表实面的人工抄本，无闸时必然漂移：#122 机械 −2 后 CLAUDE.md 仍列着早已按
+   * ADR-0009 删除的 `doc-freshness-check`，声明 22 而实面 21。三向钉死——计数等于条数、
+   * 无幽灵条目、无漏列条目。
+   */
+  it('CLAUDE.md 与 cli/commands/CONTEXT.md 的命令抄本与定义表实面双向一致', () => {
+    const actual = [
+      ...COMMAND_DEFINITIONS.map(d => d.command.split(' ')[0]),
+      ...GATE_DEFINITIONS.map(d => d.cli.command.split(' ')[0]),
+    ].sort();
+
+    const claudeLine = fs
+      .readFileSync(path.join(repoRoot, 'CLAUDE.md'), 'utf-8')
+      .split('\n')
+      .find(line => line.includes('| `src/cli/commands/` |'));
+    expect(claudeLine).toBeDefined();
+    const claudeMatch = (claudeLine || '').match(/(\d+) CLI subcommands \(([^)]*)\)/);
+    expect(claudeMatch).toBeDefined();
+    const claudeNames = claudeMatch![2]
+      .split(',')
+      .map(name => name.trim())
+      .filter(Boolean)
+      .sort();
+    expect(Number(claudeMatch![1])).toBe(actual.length);
+    expect(claudeNames).toEqual(actual);
+
+    const contextDoc = fs.readFileSync(path.join(repoCommandsDir, 'CONTEXT.md'), 'utf-8');
+    const contextCount = contextDoc.match(/(\d+) 个顶层命令/);
+    expect(contextCount).toBeDefined();
+    expect(Number(contextCount![1])).toBe(actual.length);
+    const contextNames = [
+      ...(contextDoc.match(/各命令文件：([^\n]+)/)?.[1] || '').split('/'),
+      ...(contextDoc.match(/门禁命令实现在 ([^（]+)（/)?.[1] || '').split('/'),
+    ]
+      .map(name => name.replace(/`/g, '').trim())
+      .filter(Boolean)
+      .sort();
+    expect(contextNames).toEqual(actual);
+  });
+
   it('命令定义无重复注册名', () => {
     const names = COMMAND_DEFINITIONS.map(d => d.command);
     expect(new Set(names).size).toBe(names.length);