@dommaker/harness 1.6.0 → 1.8.0

package/src/__tests__/layering.test.ts

@@ -1,10 +1,14 @@
 /**
- * 单向分层守卫（架构评审 2026-09-02 · 候选9 / harness#88）
+ * 单向分层守卫（架构评审 2026-09-02 · 候选9 / harness#88；逐目录参数化 harness#137）
  *
- * 分层 `types → utils → core → 领域层 → cli` 此前只是文档约定。本文件把它落成两件事：
- * 1. 真扫描：src/core/** 对 cli / gates / monitoring 零**值**导入（type-only 允许）
- * 2. 真规则：eslint.config.mjs 的 no-restricted-imports 对上行值导入报 error，
- *    并允许 type-only（探针在纯 node 进程里跑仓内真配置，代码不落盘）
+ * 分层 `types → utils → core → 领域层 → cli` 此前只是文档约定。本文件把它落成三件事：
+ * 1. 真扫描：**每个顶层单元（目录或 src 根文件）声明允许值导入的下行集合**，集合外的跨目录
+ *    值 import 一律红。harness#88 时只守 `src/core/** ↛ cli/gates/monitoring` 一条边，
+ *    types/utils 的回边与领域层互 import 全部放行；#137 改成逐目录冻结。
+ * 2. 真规则：eslint.config.mjs 的 no-restricted-imports 对 core 上行值导入报 error，
+ *    并允许 type-only（探针在纯 node 进程里跑仓内真配置，代码不落盘）。
+ * 3. 反证：扫描器对合成 import 语句真报违例、指名到目录与边，且合法边不误报
+ *    （不靠往 src 里塞临时文件——那是能被别的测试与 tsc 扫到的污染）。
  */
 
 import * as fs from 'fs';
@@ -31,9 +35,73 @@ new FlatESLint({ cwd: process.cwd() })
 `;
 
 const REPO_ROOT = path.resolve(__dirname, '../..');
-const CORE_DIR = path.join(REPO_ROOT, 'src', 'core');
-/** core 之下不得出现值导入的上层目录 */
-const UPPER_LAYERS = ['cli', 'gates', 'monitoring'];
+const SRC_DIR = path.join(REPO_ROOT, 'src');
+const SEP = path.sep;
+
+/** 声明「可下行到任意单元」的记号，只给顶层组合面与测试面用 */
+const ANY = '*';
+
+/**
+ * 每个顶层单元允许**值导入**的其他单元（目录名 / src 根文件名）。
+ *
+ * 口径：
+ * - 只管跨目录的**值** import：type-only 一律放行（与 eslint 侧 allowTypeImports 同口径），
+ *   同目录内的 import 也不管——本闸钉的是方向，不是模块粒度；
+ * - 集合 = 该单元的分层位置允许的下行面 + **现状冻结**的同层边（逐条注理由）。
+ *   新增一条跨目录边必须先在这里登记，diff 即评审材料；集合只多不减，
+ *   还清一条债就把对应条目删掉，留着即虚账（登记闸只管活账）。
+ */
+const DOWNSTREAM: Record<string, string[]> = {
+  // ── 叶子层 ──
+  types: [], // 谁都能 import 它，它谁都不 import：回边即分层违例（#88 前无闸可跑）
+  utils: ['types'],
+  presets: ['types'], // 纯数据（CLAUDE.md），零内部依赖
+
+  // ── core：数据/能力由调用方注入（harness#88）──
+  // presets 属数据面，project-config-loader 合并 preset 不算上行
+  core: ['presets', 'types', 'utils'],
+
+  // ── 领域层：理想下行面 = core 以下；同层边逐条记名 ──
+  agents: ['types', 'utils'],
+  'completion-checkers': ['types', 'utils'], // 纯判定函数库，commits 由调用方供给
+  failure: ['types', 'utils'],
+  gates: ['core', 'types', 'utils'],
+  knowledge: ['types', 'utils'],
+  monitoring: ['types', 'utils'],
+  release: [], // 「无内部依赖（只依赖 node fs/path）」= release/CONTEXT.md 的自我声明落成闸
+  sdd: ['types', 'utils'],
+  tools: ['types', 'utils'],
+  // 同层互 import（现状冻结，不是许可）：context 注入取知识、SessionManager 取 trace 采集器。
+  // 收口方向同 harness#88 对 core 的裁决——改注入，另票评估
+  context: ['knowledge', 'monitoring', 'types', 'utils'],
+  // bootstrapHarness 是本包组合根（装配 checker / SessionManager / TraceCollector），
+  // monitoring 对它是下行而非债
+  hooks: ['context', 'core', 'monitoring', 'types', 'utils'],
+
+  // ── 测试夹具：被各目录的测试依赖，故排在它们之下 ──
+  'test-setup': ['types', 'utils'],
+
+  // ── 顶层组合面 / 测试面：可下行到任何单元 ──
+  cli: [ANY], // CLI 是唯一的上层，per-command 懒加载各命令实现
+  'index.ts': [ANY], // 包根 barrel（ADR-0003 显式清单）
+  'pretool-use-hook.ts': ['gates', 'types', 'utils'], // 钩子入口：PreToolUse 决策取 CommandGate
+  __tests__: [ANY], // 根测试面：跨目录取生产码是本职
+};
+
+/**
+ * 测试文件（目录段含 `__tests__`）在 `DOWNSTREAM` 之外额外放行的边。
+ *
+ * 单列而不并进目录集合，是因为并进去等于宣布生产面也有这条边：
+ * - `'*'`：任何目录的测试都能用 test-setup 夹具；
+ * - core 的测试回读包根 barrel，钉「公共面确实经 `src/index.ts` 导出」这条链
+ *   （`agent-prompt-renderer` / `check-cache` 两处，ADR-0022 手法）；
+ * - failure 的 recorder 测试顺带覆盖 CLI `failure list/stats`。
+ */
+const TEST_ONLY_EDGES: Record<string, string[]> = {
+  '*': ['test-setup'],
+  core: ['index.ts'],
+  failure: ['cli'],
+};
 
 /** import / export-from / require / 动态 import 的源串 + 子句 */
 const MODULE_SOURCE_REGEX =
@@ -62,22 +130,68 @@ function isTypeOnlyClause(clause: string): boolean {
   return /^\s*type(\s|\{|$)/.test(clause);
 }
 
-/** 收集一个文件里所有指向上层的值导入源串 */
-function upwardValueImports(file: string): string[] {
-  const text = stripComments(fs.readFileSync(file, 'utf-8'));
-  const hits: string[] = [];
+/** src 相对路径 → 顶层单元名（目录名，或 src 根文件名） */
+function unitOf(relFromSrc: string): string {
+  const sep = relFromSrc.indexOf(SEP);
+  return sep === -1 ? relFromSrc : relFromSrc.slice(0, sep);
+}
+
+/** 一个 import 源串指向的单元；非相对路径（node/包名）与 src 之外返回 null */
+function unitOfImport(fromFile: string, source: string): string | null {
+  if (!source.startsWith('.')) return null;
+  const resolved = path.resolve(path.dirname(fromFile), source);
+  const relToSrc = path.relative(SRC_DIR, resolved);
+  if (!relToSrc || relToSrc.startsWith('..')) return null;
+  const unit = unitOf(relToSrc);
+  // src 根文件的 import 不带扩展名（`'../index'` → src/index.ts）：单元名按磁盘真名补回扩展，
+  // 否则根文件单元在 import 侧叫 index、在登记侧叫 index.ts，两边对不上
+  if (unit === relToSrc && fs.existsSync(path.join(SRC_DIR, `${unit}.ts`))) return `${unit}.ts`;
+  return unit;
+}
+
+function isTestFile(relFromSrc: string): boolean {
+  return `${SEP}${relFromSrc}${SEP}`.includes(`${SEP}__tests__${SEP}`);
+}
+
+interface Violation {
+  unit: string;
+  file: string;
+  target: string;
+  source: string;
+}
+
+/** 一个单元的允许集合（含测试放行与自身） */
+function allowedTargetsFor(relFromSrc: string): Set<string> {
+  const unit = unitOf(relFromSrc);
+  const allowed = new Set(DOWNSTREAM[unit] ?? []);
+  if (isTestFile(relFromSrc)) {
+    for (const extra of TEST_ONLY_EDGES['*'] ?? []) allowed.add(extra);
+    for (const extra of TEST_ONLY_EDGES[unit] ?? []) allowed.add(extra);
+  }
+  allowed.add(unit);
+  return allowed;
+}
+
+/**
+ * 扫一段代码里越界的跨目录值 import（纯函数：代码不来自磁盘，真扫描与反证共用一把尺）
+ *
+ * `relPath` 用于算自身单元，并出现在报错形状里（指名到文件与边）。
+ */
+function scanViolations(relPath: string, code: string): Violation[] {
+  const unit = unitOf(relPath);
+  const allowed = allowedTargetsFor(relPath);
+  const absFile = path.join(SRC_DIR, relPath);
+
+  const hits: Violation[] = [];
   MODULE_SOURCE_REGEX.lastIndex = 0;
   let match: RegExpExecArray | null;
-  while ((match = MODULE_SOURCE_REGEX.exec(text)) !== null) {
+  while ((match = MODULE_SOURCE_REGEX.exec(code)) !== null) {
     const clause = match[1] ?? '';
     const source = match[2] ?? match[3];
     if (match[1] && isTypeOnlyClause(clause)) continue;
-    if (!source.startsWith('.')) continue;
-    const resolved = path.resolve(path.dirname(file), source);
-    const relToSrc = path.relative(path.join(REPO_ROOT, 'src'), resolved);
-    if (UPPER_LAYERS.some(layer => relToSrc === layer || relToSrc.startsWith(layer + path.sep))) {
-      hits.push(source);
-    }
+    const target = unitOfImport(absFile, source);
+    if (target === null || allowed.has(ANY) || allowed.has(target)) continue;
+    hits.push({ unit, file: relPath, target, source });
   }
   return hits;
 }
@@ -93,17 +207,95 @@ function probeCore(code: string, filePath = 'src/core/constraints/__layering_pro
   return messages.filter(m => m.ruleId === '@typescript-eslint/no-restricted-imports');
 }
 
-describe('core 单向分层（harness#88）', () => {
-  describe('真扫描：core/** 零上行值导入', () => {
-    it('src/core 下每个文件对 cli/gates/monitoring 都没有值导入', () => {
-      const offenders = listTsFiles(CORE_DIR)
-        .map(file => ({ file: path.relative(REPO_ROOT, file), hits: upwardValueImports(file) }))
-        .filter(entry => entry.hits.length > 0);
+/** src 下现存的顶层单元（目录 + 根 .ts 文件），供登记闸对撞 */
+function currentUnits(): string[] {
+  const units: string[] = [];
+  for (const entry of fs.readdirSync(SRC_DIR, { withFileTypes: true })) {
+    if (entry.isDirectory()) units.push(entry.name);
+    else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts')) {
+      units.push(entry.name);
+    }
+  }
+  return units;
+}
+
+describe('逐目录单向分层（harness#88 / #137）', () => {
+  describe('登记闸：每个顶层单元都声明了下行集合', () => {
+    it('src 下没有未登记的单元（新增目录先登记，不得绕过本闸）', () => {
+      const unregistered = currentUnits().filter(unit => !(unit in DOWNSTREAM));
+      expect(unregistered).toEqual([]);
+    });
+
+    it('登记的单元在 src 下真实存在（目录改名或删除后不留死账）', () => {
+      const alive = new Set(currentUnits());
+      const dead = Object.keys(DOWNSTREAM).filter(unit => !alive.has(unit));
+      expect(dead).toEqual([]);
+    });
+  });
 
+  describe('真扫描：每个文件的值 import 都落在声明过的下行集合内', () => {
+    it.each(Object.keys(DOWNSTREAM))('%s 零越界值 import', unit => {
+      const root = path.join(SRC_DIR, unit); // 目录或 src 根文件
+      const files = fs.statSync(root).isDirectory() ? listTsFiles(root) : [root];
+      const offenders = files
+        .map(file =>
+          scanViolations(path.relative(SRC_DIR, file), stripComments(fs.readFileSync(file, 'utf-8')))
+        )
+        .filter(hits => hits.length > 0);
       expect(offenders).toEqual([]);
     });
   });
 
+  describe('反证：越界方向真被报出并指名到目录与边', () => {
+    it.each([
+      // [注入位置（src 相对）, 值 import 源串, 目录, 被禁目标]
+      ['types/probe.ts', '../cli/commands/definitions', 'types', 'cli'],
+      ['types/probe.ts', '../core/project-config-loader', 'types', 'core'],
+      ['types/probe.ts', '../utils/jsonl', 'types', 'utils'],
+      ['utils/probe.ts', '../core/constraints/checker', 'utils', 'core'],
+      ['core/constraints/probe.ts', '../../monitoring/traces', 'core', 'monitoring'],
+      ['core/constraints/probe.ts', '../../knowledge/store', 'core', 'knowledge'],
+      ['core/constraints/probe.ts', '../../cli/commands/definitions', 'core', 'cli'],
+      ['knowledge/probe.ts', '../context/session-manager', 'knowledge', 'context'],
+      ['monitoring/probe.ts', '../gates/registry', 'monitoring', 'gates'],
+      ['presets/probe.ts', '../core/constraints/definitions', 'presets', 'core'],
+      ['release/probe.ts', '../core/effective-constraints', 'release', 'core'],
+    ])('%s 值导入 %s 报违例（%s ↛ %s）', (rel, source, unit, target) => {
+      const code = `import { something } from '${source}';\nexport const use = something;\n`;
+      expect(scanViolations(rel, code)).toEqual([{ unit, file: rel, target, source }]);
+    });
+
+    it('报错形状带得出是哪条边（源串与文件都在内，不需人再 grep）', () => {
+      // 行首动态 import（正则的另一支；行中 require 从来不在 MODULE_SOURCE_REGEX 覆盖面内）
+      const [violation] = scanViolations(
+        'types/probe.ts',
+        `import('../cli/commands/check').then(m => m.check);\n`
+      );
+      expect(violation).toMatchObject({ unit: 'types', target: 'cli', source: '../cli/commands/check' });
+    });
+
+    it.each([
+      ['core/constraints/probe.ts', `import type { GateDefinition } from '../../gates/definitions';`],
+      ['types/probe.ts', `import type { RunEnv } from '../core/constraints/run-env';`],
+      ['knowledge/probe.ts', `import { DEFAULT_DECAY_CONFIG } from './types';`],
+      ['context/probe.ts', `import { KnowledgeQuery } from '../knowledge/query';`],
+      ['hooks/probe.ts', `import { getTraceCollector } from '../monitoring/traces';`],
+      ['core/probe.ts', `import { PRESETS_BY_NAME } from '../presets';`],
+      ['failure/__tests__/probe.test.ts', `import { failureList } from '../../cli/commands/failure';`],
+      ['core/constraints/__tests__/probe.test.ts', `import { checkConstraints } from '../../index';`],
+      ['gates/__tests__/probe.test.ts', `import { createProjectFixture } from '../../test-setup/project-fixture';`],
+      ['monitoring/probe.ts', `import * as fs from 'fs';`],
+      ['monitoring/probe.ts', `const hint = 'src/gates/registry.ts';\nexport const h = hint;`],
+    ])('合法边与噪声不误报：%s', (rel, statement) => {
+      expect(scanViolations(rel, `${statement}\n`)).toEqual([]);
+    });
+
+    it('文档注释里的示例 import 不算依赖', () => {
+      const code = `/** 用法：import { check } from '../../cli/commands/check'; */\nexport const x = 1;\n`;
+      expect(scanViolations('core/constraints/probe.ts', code)).toEqual([]);
+    });
+  });
+
   describe('真规则：eslint 上行值导入报 error', () => {
     it.each([
       ['monitoring', '../../monitoring/traces'],

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

@@ -6,15 +6,16 @@ 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 { mkdirSync, rmSync, writeFileSync, mkdtempSync } from 'fs';
 import { join } from 'path';
+import { tmpdir } from 'os';
 
 describe('PassesGate', () => {
-  const tempDir = join(process.cwd(), 'temp-test-passes-gate');
+  let tempDir: string;
   let gate: PassesGate;
 
   beforeAll(() => {
-    mkdirSync(tempDir, { recursive: true });
+    tempDir = mkdtempSync(join(tmpdir(), 'temp-test-passes-gate-'));
     
     // 创建简单的 package.json
     writeFileSync(join(tempDir, 'package.json'), JSON.stringify({
@@ -47,13 +48,17 @@ describe('PassesGate', () => {
   // 探测正本行为钉住（架构评审 A2：CLI/core 双版收口后的统一语义，
   // 此前 e2e 优先级、echo 排除、兜底均无测试钉住）
   describe('detectTestCommand 正本（统一探测顺序）', () => {
-    const detectDir = join(process.cwd(), 'temp-test-detect-command');
+    let detectDir: string;
 
     const writePkg = (dir: string, scripts: Record<string, string>) => {
       mkdirSync(dir, { recursive: true });
       writeFileSync(join(dir, 'package.json'), JSON.stringify({ name: 'detect-case', scripts }));
     };
 
+    beforeAll(() => {
+      detectDir = mkdtempSync(join(tmpdir(), 'temp-test-detect-command-'));
+    });
+
     afterAll(() => {
       try {
         rmSync(detectDir, { recursive: true, force: true });

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

@@ -6,12 +6,13 @@ import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
 import { PerformanceGate } from '../gates/performance';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 describe('PerformanceGate', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-perf-gate');
+  let tempDir: string;
 
   beforeAll(() => {
-    fs.mkdirSync(tempDir, { recursive: true });
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-perf-gate-'));
   });
 
   afterAll(() => {
@@ -23,27 +24,14 @@ describe('PerformanceGate', () => {
   });
 
   describe('check', () => {
-    it('禁用时应该返回通过', async () => {
-      const gate = new PerformanceGate({ enabled: false });
-
-      const result = await gate.check({
-        projectId: 'test',
-        projectPath: tempDir,
-      });
-
-      expect(result.passed).toBe(true);
-    });
-
     it('应该返回检查结果', async () => {
       const gate = new PerformanceGate({
-        enabled: true,
         thresholds: {
           maxBundleSize: 1000,
         },
       });
 
       const result = await gate.check({
-        projectId: 'test',
         projectPath: tempDir,
       });
 

package/src/__tests__/project-config-loader-extra.test.ts

@@ -3,15 +3,18 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll, jest } from '@jest/globals';
-import { ProjectConfigLoader } from '../core/project-config-loader';
+import { ProjectConfigLoader, isConstraintRetired } from '../core/project-config-loader';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 describe('ProjectConfigLoader - 补充覆盖', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-config-extra');
-  const harnessDir = path.join(tempDir, '.harness');
+  let tempDir: string;
+  let harnessDir: string;
 
   beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-config-extra-'));
+    harnessDir = path.join(tempDir, '.harness');
     fs.mkdirSync(harnessDir, { recursive: true });
   });
 
@@ -123,71 +126,42 @@ custom_constraints:
     });
   });
 
-  describe('isConstraintEnabled', () => {
-    it('启用的约束应该返回 true', () => {
+  describe('零消费者收缩（harness#137）', () => {
+    /**
+     * `isConstraintEnabled` / `getConstraintSource` 属 ADR-0022 型漏收：
+     * 除本文件与自身测试外双仓零消费者，生效集判定唯一来源是
+     * `mergeConstraints` → `getEffectiveConstraints`（ADR-0001），这两个查询函数是它的平行复印。
+     */
+    it('isConstraintEnabled / getConstraintSource 已从类面删除', () => {
       const loader = new ProjectConfigLoader(tempDir);
       loader.load();
 
-      expect(loader.isConstraintEnabled('no_bypass_checkpoint')).toBe(true);
-    });
-
-    it('禁用的约束应该返回 false', () => {
-      fs.writeFileSync(
-        path.join(harnessDir, 'config.yml'),
-        `
-constraints:
-  test_disabled:
-    enabled: false
-`
-      );
-
-      const loader = new ProjectConfigLoader(tempDir);
-      loader.load();
-
-      expect(loader.isConstraintEnabled('test_disabled')).toBe(false);
+      // @ts-expect-error isConstraintEnabled 零消费者，随 harness#137 删除
+      expect(loader.isConstraintEnabled).toBeUndefined();
+      // @ts-expect-error getConstraintSource 零消费者，随 harness#137 删除
+      expect(loader.getConstraintSource).toBeUndefined();
+      expect(ProjectConfigLoader.prototype).not.toHaveProperty('isConstraintEnabled');
+      expect(ProjectConfigLoader.prototype).not.toHaveProperty('getConstraintSource');
     });
   });
 
-  describe('getConstraintSource', () => {
-    it('内置约束应该返回 built-in', () => {
-      const loader = new ProjectConfigLoader(tempDir);
-      loader.load();
-
-      expect(loader.getConstraintSource('no_bypass_checkpoint')).toBe('built-in');
+  describe('isConstraintRetired（退役判定单点，harness#137）', () => {
+    it('config.yml enabled:false 即已退役，与 custom 条目无关', () => {
+      expect(isConstraintRetired(undefined, true)).toBe(true);
     });
 
-    it('自定义约束应该返回 custom', () => {
-      fs.writeFileSync(
-        path.join(harnessDir, 'config.yml'),
-        `
-custom_constraints:
-  custom_source_test:
-    rule: CUSTOM
-    message: Custom
-    trigger: commit
-`
-      );
-
-      const loader = new ProjectConfigLoader(tempDir);
-      loader.load();
-
-      expect(loader.getConstraintSource('custom_source_test')).toBe('custom');
+    it('custom 条目带 retired 元数据即已退役（studio#82 D6 落点在条目自身）', () => {
+      expect(isConstraintRetired({ retired: { at: '2026-08-08T12:00:00.000Z' } }, false)).toBe(true);
     });
 
-    it('禁用约束应该返回 disabled', () => {
-      fs.writeFileSync(
-        path.join(harnessDir, 'config.yml'),
-        `
-constraints:
-  source_disabled:
-    enabled: false
-`
-      );
-
-      const loader = new ProjectConfigLoader(tempDir);
-      loader.load();
+    it('两个落点都没命中 → 未退役', () => {
+      expect(isConstraintRetired(undefined, false)).toBe(false);
+      expect(isConstraintRetired({ retired: undefined }, false)).toBe(false);
+    });
 
-      expect(loader.getConstraintSource('source_disabled')).toBe('disabled');
+    it('retired 段的假值（null / 空串）不算退役——mergeConstraints 用的是 truthiness', () => {
+      expect(isConstraintRetired({ retired: null }, false)).toBe(false);
+      expect(isConstraintRetired({ retired: '' }, false)).toBe(false);
     });
   });
 

package/src/__tests__/project-config-loader.test.ts

@@ -6,12 +6,15 @@ import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
 import { ProjectConfigLoader, getCapabilitiesMode } from '../core/project-config-loader';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 describe('ProjectConfigLoader', () => {
-  const tempDir = path.join(process.cwd(), 'temp-test-config');
-  const harnessDir = path.join(tempDir, '.harness');
+  let tempDir: string;
+  let harnessDir: string;
 
   beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'temp-test-config-'));
+    harnessDir = path.join(tempDir, '.harness');
     fs.mkdirSync(harnessDir, { recursive: true });
   });
 
@@ -125,7 +128,7 @@ custom_rules:
   });
 
   describe('getCapabilitiesMode', () => {
-    /** 建一个带独立 .harness/config.yml 的临时项目目录（避免进程级缓存串扰） */
+    /** 建一个带独立 .harness/config.yml 的临时项目目录（各用例独占自己的配置内容） */
     const setupConfigDir = (name: string, configYaml: string): string => {
       const dir = path.join(tempDir, name);
       fs.mkdirSync(path.join(dir, '.harness'), { recursive: true });

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

@@ -5,9 +5,13 @@
  * 改动 src/index.ts 导出清单时同步更新本文件的 EXPECTED_RUNTIME_EXPORTS，
  * diff 即 PR 评审材料。
  *
- * 两个面两道闸：运行时（值）导出由 Object.keys 逐字冻结；纯类型导出在运行时不可见，
- * 由下方「包根类型面」闸把关——编译期 `@ts-expect-error` 钉已删类型 + 源形状钉整条 barrel 链。
- * 类型面曾有此空缺时 `PassesGateResult` 漏删未被抓到（review A2），钉子据此补上。
+ * 类型面共三道闸，本文件占前两道：① 运行时（值）导出由 Object.keys 逐字冻结；② 下方「包根
+ * 类型面」闸钉的是**删完之后**——编译期 `@ts-expect-error` 钉已删类型 + 源形状钉整条 barrel 链
+ * （`PassesGateResult` 曾从 #125「关联类型导出随迁」漏删且无测试可捕获，review A2 据此补钉）。
+ * 第 ③ 道是类型面**全量清单**冻结，在 `public-type-surface.test.ts`（ADR-0022 追记 4）；它刻意
+ * 不 import 包根，因为本文件的编译期钉在类型面被改动时会让整套 suite「failed to run」（实测注入
+ * 一条 `export type { DynamicTask }` 得 0 tests），拿不到可执行的清单 diff——定级阶段那句
+ * 「这个符号在不在包根导出面」由第 ③ 道回答，不由人的 grep 记忆回答。
  */
 
 import * as fs from 'fs';
@@ -96,7 +100,6 @@ const EXPECTED_RUNTIME_EXPORTS = [
   'getConstraint',
   'getCriticalArtifacts',
   'getEffectiveConstraints',
-  'getEffectiveGates',
   'getFailureLevel',
   'getGate',
   'getRegistryPath',
@@ -137,6 +140,10 @@ describe('公共导出清单（ADR-0003）', () => {
  * `PassesGateResult`（已删 `setPasses` 的返回形状）正是这样从 #125 的「关联类型导出随迁」
  * 里漏掉、经四级 barrel 存活为公开类型。手法同 #125 的 AC-007：编译期 `@ts-expect-error`
  * 钉住删除 + 源形状钉住整条链，活类型正钉防删多。
+ *
+ * `DynamicTask` 是同案的第二个漏收项（二次复审 B1）：它是 `setPasses(taskId, workDir, task?)`
+ * 的入参形状，#125 删掉 setPasses 后只剩私有 `runTest` 那个从不读取的 `_task` 形参在供养它，
+ * 而包根同名导出取自 `./types/passes-gate`（见 5959b79），所以它是**公开的**死类型。
  */
 describe('包根类型面（ADR-0022 关联类型随迁）', () => {
   const BARREL_CHAIN = [
@@ -146,14 +153,22 @@ describe('包根类型面（ADR-0022 关联类型随迁）', () => {
     '../index.ts',
   ];
 
-  it('PassesGateResult 在整条 barrel 链四级都已消失', () => {
+  function expectAbsentAcrossBarrelChain(typeName: string): void {
     for (const rel of BARREL_CHAIN) {
       const source = fs.readFileSync(path.join(__dirname, rel), 'utf-8');
-      expect({ file: rel, mentions: /PassesGateResult/.test(source) }).toEqual({
+      expect({ file: rel, mentions: source.includes(typeName) }).toEqual({
         file: rel,
         mentions: false,
       });
     }
+  }
+
+  it('PassesGateResult 在整条 barrel 链四级都已消失', () => {
+    expectAbsentAcrossBarrelChain('PassesGateResult');
+  });
+
+  it('DynamicTask 在整条 barrel 链四级都已消失', () => {
+    expectAbsentAcrossBarrelChain('DynamicTask');
   });
 
   it('PassesGateResult 不再是包根可导入类型（编译期钉）', () => {
@@ -162,6 +177,12 @@ describe('包根类型面（ADR-0022 关联类型随迁）', () => {
     expect(removedType).toBeUndefined();
   });
 
+  it('DynamicTask 不再是包根可导入类型（编译期钉）', () => {
+    // @ts-expect-error 该类型是已删 setPasses 的 task 入参形状，消费者净删后随 A2 同案收口
+    const removedType: import('../index').DynamicTask | undefined = undefined;
+    expect(removedType).toBeUndefined();
+  });
+
   it('活类型仍可经包根导入（防止删多）', () => {
     const liveCheck: import('../index').PassesGateCheckResult = { allowed: true };
     const liveTask: import('../index').TaskTestResult = { passed: true, command: 'npm test' };