@dommaker/harness 1.4.0 → 1.6.0

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

@@ -5,6 +5,7 @@
 import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
 import { PassesGate, createPassesGate, detectTestCommand } from '../core/validators/passes-gate';
 import type { TaskTestResult } from '../types/passes-gate';
+import { createProjectFixture } from '../test-setup/project-fixture';
 import { mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join } from 'path';
 
@@ -32,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 () => {
@@ -71,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 正本（统一探测顺序）', () => {
@@ -152,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 });
     });
   });
 
@@ -224,33 +131,25 @@ describe('PassesGate', () => {
    * （extractCoverage → TaskTestResult.coverage）整体删除，结果面不再有 coverage 字段。
    */
   describe('覆盖率取数路删除（harness#94）', () => {
-    const covDir = join(process.cwd(), 'temp-test-no-coverage-field');
-
-    beforeAll(() => {
-      mkdirSync(covDir, { recursive: true });
-
-      // 输出里放一份 jest 覆盖率表：删除前 extractCoverage 会从中抠出 80.5 填进结果字段
-      writeFileSync(join(covDir, 'package.json'), JSON.stringify({
-        name: 'coverage-project',
-        scripts: { test: 'echo "All files | 80.50 | 70.21 | 83.33 | 79.59 |"' },
-      }));
-    });
-
-    afterAll(() => {
-      try {
-        rmSync(covDir, { recursive: true, force: true });
-      } catch {
-        // ignore
-      }
-    });
-
-    it('setPasses 结果不带 coverage 字段', async () => {
+    // 临时根走 createProjectFixture 正本（tmpdir，mkdtemp 劫持统一回收），不建在仓内
+    const covDir = createProjectFixture({
+      name: 'pg-no-coverage',
+      files: {
+        // 输出里放一份 jest 覆盖率表：删除前 extractCoverage 会从中抠出 80.5 填进结果字段
+        'package.json': JSON.stringify({
+          name: 'coverage-project',
+          scripts: { test: 'echo "All files | 80.50 | 70.21 | 83.33 | 79.59 |"' },
+        }),
+      },
+    });
+
+    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,8 +29,9 @@ 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()` 兜底形状、下游层（core/gates/context/monitoring/hooks）cwd 站点集合冻结、`xxxPath: '相对值'` 默认值冻结；豁免逐条带理由，站点消失却不删条目同样失败
+  - 机器可检：`__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」这类静态看不出的漂移由它守，冻结表守的是不再新增站点
 - **读到部分结果必须告知（harness#100）**：命令面以 `skip` 策略读 JSONL（traces.log / failures.log）时，坏行计数要到用户可见输出，**不允许默默丢弃**。共同约束：无损坏零噪声（计数为 0 不出行）、不改任何既有计数口径（`status` 的 `记录数` 仍是原始非空行数，逐字节不变）、计数一律取自 `src/utils/jsonl` 读链返回的 `skippedLines`（经报告入口透传或在读点就地取用），**禁止**用「原始行数 − 统计条数」反推（窗过滤掉的合法行与坏行分不开）。三处落点各自对得上一行代码：
   - `status`：告知**走 stderr**（`logError(io, …)`），因为 stdout 是报告体、其字节已被 `记录数` 那一行定死，挤进去等于改输出
@@ -43,7 +44,7 @@ H5（#44）起：
 - init 治理约束段写入落点（studio #302，ADR 2026-08-21 落点模型）：新仓 → AGENTS.md `PRESERVE:governance` 段（sync-docs 重新生成时保留）；旧模型仓（CLAUDE.md 已有 HARNESS_CONSTRAINTS 标记或 `## Governance Rules` 块）→ 续写 CLAUDE.md，幂等重跑不制造双份正本。治理段「在场守护」由 core 侧 governance_presence checker 承担（段缺失/为空时 check 报警）
 - PRESERVE:governance 段内写入纪律：机器管理的只有 HARNESS_CONSTRAINTS 标记区间——有标记只换标记区间，无标记（纯手写段）在段尾追加注入段；段内其余手写内容（治理契约引言/流程/纪律等）必须原样保留（曾整段替换清空手写内容的回归，init-injection.test 有防回归用例）
 - 注入段落点路由与 marker-range 替换收口在 `core/constraints/injection-writer`（ADR-0011）：读侧 `resolveInjectionTarget`（漂移检测/retire 同步共用「CLAUDE.md 有标记优先，否则 AGENTS.md」）+ 写侧 `resolveGovernanceLanding`（init 落点选择）；init 三个治理段 writer 与 retire 注入同步均为「渲染 body + 调 writer」，半标记（单边/乱序）一律拒写告警；未注入 = 两处均无完整标记段
-- knowledge 命令包含 13 个子操作（list/search/import/decay/stats/upsert/sync-status/sync-rag/audit/snapshot/migrate/index/health）
+- knowledge 命令包含 11 个子操作（list/search/import/decay/stats/sync-rag/audit/snapshot/migrate/index/health）；upsert/sync-status 已迁至 studio CLI（harness#110，二者硬编码 localhost Studio 内部端点，不属 harness「通用框架、文件驱动」定位）
 - `stats` / `health` 的飞轮数字不在 CLI 内计算：分子口径唯一实现是 `knowledge/flywheel-metrics.ts`（`evaluateFlywheel`，ADR-0013），本层只做百分比取整/一位小数与字段名映射；`.consumption-stats.json` 的读取留在各命令（module 零 IO）
 - 特殊路由（选项条件、子命令兜底、裸跑语义）表达在定义表的 optionRoutes / subcommands / subcommandStrict / bareRunsAction 字段，bin 是纯通用引擎、不含单命令知识
 - **命令 interface = `CommandResult` + 注入 io（架构评审候选7）**：命令实现一律声明 `Promise<CommandResult>`（判别联合 `ok|skip|fail|usage-error`，`fail`/`usage-error` 必附可定位的 `reason`，多闸门命令 reason 含 `gate <id>`），末位可选形参 `io: CommandIO = processIO`；类型与写入面在 `src/cli/command-contract.ts`

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

@@ -67,6 +67,12 @@ describe('命令实现/定义表目录零 process.exit（唯一出口在 bin）'
   });
 });
 
+// CI 上 dist 缺失时显式失败而非静默 skip（harness#99）：#86 退出语义的
+// 唯一端到端证据在下面的 smoke 块，CI 必须先 build 再 test，否则主证据隐形。
+if (!hasDist && process.env.CI) {
+  throw new Error('dist 未构建：bin 端到端 smoke 不得静默 skip —— CI 必须先 npm run build 再 npm test（harness#99）');
+}
+
 const smoke = hasDist ? describe : describe.skip;
 
 smoke('端到端：真实命令经 bin 映射后的对外退出码', () => {

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

@@ -200,6 +200,8 @@ describe('check command（真 git fixture）', () => {
       stageChange(
         dir,
         'src/existing.ts',
+        // 'pass'+'word' 拆串是躲本仓 no_hardcoded_credentials 静态扫描：测试源文件里出现完整
+        // `password = "..."` 字面量会撞自己的 pre-commit 门禁；运行时拼接值不变，断言不受影响
         'export const a = 1;\nconst pass' + 'word = "correcthorsebattery";\n'
       );
       passTraces(dir);
@@ -240,6 +242,78 @@ describe('check command（真 git fixture）', () => {
     });
   });
 
+  describe('判定证据外显（harness#119）', () => {
+    /** 带 CAPABILITIES.md 的 git 仓库：登记列表外的源文件即为仓库级漂移 */
+    function capRepo(registered: string[]): string {
+      const dir = gitRepo();
+      const rows = registered
+        .map((rel) => `| ${path.basename(rel, '.ts')} | ${rel} | fixture |\n`)
+        .join('');
+      write(dir, 'CAPABILITIES.md', `# C\n\n| 模块 | 文件 | 说明 |\n|------|------|------|\n${rows}`);
+      git(dir, 'add', 'CAPABILITIES.md');
+      git(dir, 'commit', '-q', '-m', 'capabilities');
+      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);
+    }
+
+    it('变更文件未登记 → 警告随附证据点名该文件', async () => {
+      const dir = capRepo(['src/existing.ts', 'src/nested/deep.ts']);
+      stageChange(dir, 'src/nested/extra.ts', 'export const e = 1;\n');
+      passTraces(dir);
+
+      const result = await check(
+        { preset: 'standard', staged: true, projectPath: dir, trigger: 'module_modification' },
+        io
+      );
+
+      expect(io.outText()).toContain('- capability_sync');
+      expect(io.outText()).toContain('src/nested/extra.ts');
+      expect(result).toEqual({ kind: 'ok' });
+    });
+
+    it('仓库级漂移（与本次变更无关）→ 提示块露出，不判违规', async () => {
+      const dir = capRepo(['src/existing.ts']);
+      passTraces(dir);
+
+      const result = await check(
+        { preset: 'standard', staged: true, projectPath: dir, trigger: 'module_modification' },
+        io
+      );
+
+      const out = io.outText();
+      expect(out).toContain('✅ 指导原则: 1/1 通过');
+      expect(out).not.toContain('指导原则警告');
+      expect(out).toContain('💡 提示: 1 条（不判违规，供参考）');
+      expect(out).toContain('- capability_sync:');
+      expect(out).toContain('src/nested/deep.ts');
+      expect(out).toContain('✅ 约束检查通过');
+      expect(result).toEqual({ kind: 'ok' });
+    });
+
+    it('提示与违规都写进 trace 的 evidence 字段（统计侧可诊断）', async () => {
+      const dir = capRepo(['src/existing.ts']);
+      passTraces(dir);
+
+      await check(
+        { preset: 'standard', staged: true, projectPath: dir, trigger: 'module_modification' },
+        io
+      );
+
+      const record = traceOf('capability_sync');
+      expect(record?.result).toBe('pass');
+      expect(record?.evidence?.join('\n')).toContain('src/nested/deep.ts');
+    });
+  });
+
   describe('git 证据单一来源（#87 验收）', () => {
     it('两个 checker 请求同一份 staged diff → 一次 run 内只 spawn 一次', async () => {
       // 新增（非删除）测试行：no_test_simplification 请求 stagedDiff 后放行，

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