@dommaker/harness 1.7.0 → 1.8.0

package/src/core/effective-set.ts

@@ -1,50 +1,34 @@
 /**
  * 生效集共享筛选器（ADR-0001 收口）
  *
- * 「config.yml 引用了哪些 id、哪些被禁用」的判定，约束侧与门禁侧共用一份：
- * - 约束侧（ProjectConfigLoader.mergeConstraints）：未知 id 静默忽略，
- *   收集进结果 unknownIds 供诊断（历史配置可能存在已移除约束的禁用残留）
- * - 门禁侧（getEffectiveGates）：未知 id 抛错（闭环校验；gates 配置段为
- *   新增面，不存在历史残留配置）
+ * 「config.yml 引用了哪些 id、哪些被 enabled:false 裁剪」的判定唯一实现。
+ * 未知 id 静默忽略并收集进结果 `unknownIds` 供诊断——历史配置可能残留已移除条目的禁用键，
+ * 故不能抛错。唯一生产调用方：`ProjectConfigLoader.mergeConstraints`。
  *
- * 行为差异仅收敛为 onUnknownId 一个开关，筛选语义两侧一致。
+ * 去向指引：本函数曾带一个按语义分的 `'throw'` 模式（引用未注册即抛错），其唯一生产调用方
+ * 消失后已按 ADR-0022 判据删除——背景见 ADR-0002 文末「后续变更」，票 harness#141。
  */
 
-export interface FilterEnabledEntriesOptions {
-  /** 未知 id 处理：'collect' 收集进结果 unknownIds；'throw' 立即抛错 */
-  onUnknownId: 'collect' | 'throw';
-
-  /** onUnknownId='throw' 时的错误消息定制（如附带可用 id 清单） */
-  unknownIdError?: (id: string) => string;
-}
-
 export interface FilterEnabledEntriesResult {
   /** enabled === false 的 id（未知 id 若带 enabled:false 同样计入，与历史行为一致） */
   disabledIds: string[];
 
-  /** 未知 id（仅 onUnknownId='collect' 时非空） */
+  /** config 条目里未注册的 id，供调用方诊断 */
   unknownIds: string[];
 }
 
 /**
- * 按 config 条目筛选：未知 id 按 onUnknownId 处理，enabled:false 收进 disabledIds
+ * 按 config 条目筛选：未知 id 收集进 unknownIds，enabled:false 收进 disabledIds
  */
 export function filterEnabledEntries(
   knownIds: ReadonlySet<string>,
-  entries: Record<string, { enabled?: boolean } | undefined>,
-  options: FilterEnabledEntriesOptions
+  entries: Record<string, { enabled?: boolean } | undefined>
 ): FilterEnabledEntriesResult {
   const disabledIds: string[] = [];
   const unknownIds: string[] = [];
 
   for (const [id, entry] of Object.entries(entries)) {
     if (!knownIds.has(id)) {
-      if (options.onUnknownId === 'throw') {
-        throw new Error(
-          options.unknownIdError?.(id) ??
-            `[harness] 配置引用了未注册的 id "${id}"。`
-        );
-      }
       unknownIds.push(id);
     }
     if (entry?.enabled === false) {

package/src/core/index.ts

@@ -81,6 +81,8 @@ export {
   getCapabilitiesMode,
 } from './project-config-loader';
 export type { CapabilitiesMode, ContextFilesResolution } from './project-config-loader';
+// 运行级观察面（ADR-0023 决策 1/2）：上面两组访问器与 ProjectConfigLoader 的入参形状
+export type { RunEnv, RunTarget } from './constraints/run-env';
 
 // 生效约束集（ADR-0001：唯一生效集来源）
 export {

package/src/core/project-config-loader.ts

@@ -1,13 +1,11 @@
 /**
  * 项目配置加载器
  *
- * 加载 .harness/config.yml 和 .harness/custom-constraints.yml
- * 合并内置约束和项目自定义约束
+ * 解读 `.harness/config.yml` 与自定义约束文件、合并内置与项目自定义约束。
+ * 本模块不碰文件系统：两份配置的读取口径 = 运行级观察面（`constraints/run-env.ts`，
+ * ADR-0023 决策 2），一次运行内各至多读一次。
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
 import type { Constraint, ConstraintTrigger } from '../types/constraint';
 import type {
   ProjectConfig,
@@ -19,6 +17,7 @@ import type {
 import { IRON_LAWS, GUIDELINES, PROMPTS } from './constraints/definitions';
 import { PRESETS_BY_NAME, STANDARD_PRESET } from '../presets';
 import { filterEnabledEntries } from './effective-set';
+import { resolveRunEnv, type RunEnv, type RunTarget } from './constraints/run-env';
 
 /**
  * 默认配置
@@ -29,48 +28,17 @@ const DEFAULT_CONFIG: ProjectConfig = {
 };
 
 /**
- * config.yml 原始解析结果的进程级缓存（工单 16）
+ * 读取并解析 `.harness/config.yml`
  *
- * 键为解析后的项目路径，条目带 mtimeMs+size 指纹：文件未变则直接复用，
- * 避免单次 harness check 内多处读取者重复 yaml 解析；文件变更自动失效。
- */
-const rawConfigCache = new Map<string, { mtimeMs: number; size: number; raw: Record<string, unknown> }>();
-
-/**
- * 读取并解析 .harness/config.yml（进程级 memoize）
+ * 实面 = `RunEnv.rawConfig()`（ADR-0023 决策 2），本函数只是它的「只此一次」形状：
+ * 传项目根字符串即自造一枚用完即弃的观察面（每次调用都读当下内容），
+ * 传调用方那枚 RunEnv 则与本 run 的其余消费方共用同一份读取。
+ * 原进程级 `rawConfigCache` + mtime/size 指纹已撤销——见 ADR-0023 决策 2 与工单 16 的撤销记录。
  *
  * 文件不存在时返回 undefined；解析失败向上抛出（由各调用方自行兜底）。
  */
-export function loadRawProjectConfig(projectPath: string): Record<string, unknown> | undefined {
-  const key = path.resolve(projectPath);
-  const configPath = path.join(key, '.harness', 'config.yml');
-
-  let stat: fs.Stats | undefined;
-  try {
-    stat = fs.statSync(configPath);
-  } catch {
-    stat = undefined;
-  }
-  // 文件缺失，或 stat 不可用（如测试 mock）且文件不存在 → 无配置
-  if (!stat?.mtimeMs && !fs.existsSync(configPath)) {
-    rawConfigCache.delete(key);
-    return undefined;
-  }
-
-  // stat 指纹可用时走缓存;不可用则每次直读(不缓存,避免脏数据)
-  if (stat?.mtimeMs !== undefined) {
-    const cached = rawConfigCache.get(key);
-    if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
-      return cached.raw;
-    }
-  }
-
-  const loaded = yaml.load(fs.readFileSync(configPath, 'utf-8')) ?? {};
-  const raw = loaded as Record<string, unknown>;
-  if (stat?.mtimeMs !== undefined) {
-    rawConfigCache.set(key, { mtimeMs: stat.mtimeMs, size: stat.size, raw });
-  }
-  return raw;
+export function loadRawProjectConfig(target: RunTarget): Record<string, unknown> | undefined {
+  return resolveRunEnv(target).rawConfig();
 }
 
 /**
@@ -81,12 +49,12 @@ export type CapabilitiesMode = NonNullable<CapabilitiesConfig['mode']>;
 /**
  * 读取 governance 段（全仓唯一手写钻取点，工单 84）
  *
- * 基于 loadRawProjectConfig 的进程级 memoize，不引入第二次 yaml 解析。
  * 配置缺失 / 解析失败 / 形状不符时返回 undefined，由调用方按未配置处理。
+ * 入参形状见 loadRawProjectConfig：传 RunEnv 即与本 run 其余消费方共用同一份 config.yml 读取。
  */
-export function getGovernanceConfig(projectPath: string): GovernanceConfig | undefined {
+export function getGovernanceConfig(target: RunTarget): GovernanceConfig | undefined {
   try {
-    const raw = loadRawProjectConfig(projectPath);
+    const raw = loadRawProjectConfig(target);
     const governance = raw?.governance;
     if (governance === null || typeof governance !== 'object') return undefined;
     return governance as GovernanceConfig;
@@ -115,8 +83,8 @@ export type ContextFilesResolution =
  * init / 扫描类工具流的自动探测回落保留在调用方，不进本访问器。
  * 元素类型在此收口：脏配置（如 required_dirs: [1]）不得流入调用方 path.join。
  */
-export function resolveContextFiles(projectPath: string): ContextFilesResolution {
-  const contextFiles = getGovernanceConfig(projectPath)?.context_files;
+export function resolveContextFiles(target: RunTarget): ContextFilesResolution {
+  const contextFiles = getGovernanceConfig(target)?.context_files;
   if (!contextFiles?.enabled) return { state: 'unconfigured' };
   const dirs = contextFiles.required_dirs;
   if (!Array.isArray(dirs) || dirs.length === 0) return { state: 'enabled-empty' };
@@ -129,22 +97,47 @@ export function resolveContextFiles(projectPath: string): ContextFilesResolution
  *
  * 配置缺失/解析失败/取值非法时一律回落 'file'。
  */
-export function getCapabilitiesMode(projectPath: string): CapabilitiesMode {
-  const mode = getGovernanceConfig(projectPath)?.capabilities?.mode;
+export function getCapabilitiesMode(target: RunTarget): CapabilitiesMode {
+  const mode = getGovernanceConfig(target)?.capabilities?.mode;
   if (mode === 'file' || mode === 'module' || mode === 'listing') return mode;
   return 'file';
 }
 
+/**
+ * 退役判定单点（studio#82 D6 一处真相）
+ *
+ * 两个落点合成一条规则：禁用（config.yml `constraints.<id>.enabled: false`，内置约束的
+ * 退役落点）或 custom 条目自带 `retired` 元数据（custom 约束的退役落点，不拆 config.yml
+ * 第二处）。`mergeConstraints` 的 custom 追加跳过与 `harness constraints retire` 的
+ * already_retired 检查共用本函数——后者此前是这条规则的手写复印（harness#137 收口）。
+ *
+ * `disabled` 由调用方给：mergeConstraints 传的是含 preset 裁剪的完整禁用集，
+ * retire 传的是 config.yml 单点（退役落点只有这一处，preset 语义不掺进退役判定）。
+ * `retired` 按 truthiness 判，与 mergeConstraints 历史口径逐字一致。
+ */
+export function isConstraintRetired(
+  customDef: { retired?: unknown } | undefined,
+  disabled: boolean
+): boolean {
+  return disabled || Boolean(customDef?.retired);
+}
+
 /**
  * 项目配置加载器
  */
 export class ProjectConfigLoader {
+  private env: RunEnv;
   private projectPath: string;
   private config: ProjectConfig;
   private customConstraints: Record<string, CustomConstraintDefinition>;
 
-  constructor(projectPath?: string) {
-    this.projectPath = projectPath || process.cwd();
+  /**
+   * @param target 项目根路径，或本 run 已构造的运行级观察面（ADR-0023 决策 2）
+   *   传观察面时 config.yml 与本 run 其余消费方共用同一份读取；传路径 = 自造一枚一次性观察面
+   */
+  constructor(target?: RunTarget) {
+    this.env = resolveRunEnv(target);
+    this.projectPath = this.env.projectPath;
     this.config = { ...DEFAULT_CONFIG };
     this.customConstraints = {};
   }
@@ -153,8 +146,8 @@ export class ProjectConfigLoader {
    * 加载项目配置
    */
   load(): ProjectConfig {
-    // 1. 加载主配置（经进程级 memoize，避免重复 yaml 解析）
-    const raw = loadRawProjectConfig(this.projectPath);
+    // 1. 加载主配置（run 内 memo 在观察面上，同一份解析结果供全部消费方共用）
+    const raw = this.env.rawConfig();
     if (raw) {
       this.config = { ...DEFAULT_CONFIG, ...(raw as Partial<ProjectConfig>) };
     }
@@ -167,24 +160,15 @@ export class ProjectConfigLoader {
 
   /**
    * 加载自定义约束
+   *
+   * 文件读取经观察面（ADR-0023 决策 2）：同一次运行内多个加载器共用同一份内容，
+   * 「哪个文件名算数」与合并顺序仍由本函数决定（方式 1 文件 → 方式 2 主配置内联，后者覆盖）。
    */
   private loadCustomConstraints(): void {
     // 方式 1：从单独文件加载
     if (this.config.custom_constraints_file) {
-      const customPath = path.join(
-        this.projectPath,
-        '.harness',
-        this.config.custom_constraints_file
-      );
-      if (fs.existsSync(customPath)) {
-        const content = fs.readFileSync(customPath, 'utf-8');
-        const loaded = yaml.load(content) as {
-          custom_constraints?: Record<string, CustomConstraintDefinition>;
-        };
-        if (loaded.custom_constraints) {
-          this.customConstraints = { ...this.customConstraints, ...loaded.custom_constraints };
-        }
-      }
+      const defs = this.env.customConstraints(this.config.custom_constraints_file);
+      this.customConstraints = { ...this.customConstraints, ...defs };
     }
 
     // 方式 2：从主配置文件中加载
@@ -253,9 +237,7 @@ export class ProjectConfigLoader {
         ...Object.keys(PROMPTS),
         ...Object.keys(this.customConstraints),
       ]);
-      const filtered = filterEnabledEntries(knownIds, this.config.constraints, {
-        onUnknownId: 'collect',
-      });
+      const filtered = filterEnabledEntries(knownIds, this.config.constraints);
       unknownIds.push(...filtered.unknownIds);
       for (const constraintId of filtered.disabledIds) {
         result.disabled.push(constraintId);
@@ -270,7 +252,7 @@ export class ProjectConfigLoader {
     // 收集进 disabled，custom 在 step 1 时尚未入桶，须在此兜底跳过；
     // 条目带 retired 元数据的同样不追加——studio#82 D6 退役落点在条目自身）
     for (const [id, customDef] of Object.entries(this.customConstraints)) {
-      if (result.disabled.includes(id) || customDef.retired) {
+      if (isConstraintRetired(customDef, result.disabled.includes(id))) {
         continue;
       }
       const constraint = this.toConstraint(customDef, id);
@@ -345,36 +327,6 @@ export class ProjectConfigLoader {
     return this.customConstraints;
   }
 
-  /**
-   * 检查约束是否启用
-   */
-  isConstraintEnabled(constraintId: string): boolean {
-    // 1. 检查是否在禁用列表
-    if (this.config.constraints?.[constraintId]?.enabled === false) {
-      return false;
-    }
-
-    // 2. 检查自定义约束是否禁用
-    if (this.customConstraints[constraintId]?.enabled === false) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * 获取约束来源
-   */
-  getConstraintSource(constraintId: string): 'built-in' | 'custom' | 'disabled' {
-    if (this.config.constraints?.[constraintId]?.enabled === false) {
-      return 'disabled';
-    }
-    if (this.customConstraints[constraintId]) {
-      return 'custom';
-    }
-    return 'built-in';
-  }
-
   /**
    * 检查是否有自定义配置
    */

package/src/core/validators/__tests__/http-retry-sleep.test.ts

@@ -0,0 +1,231 @@
+/**
+ * http 检查项的重试退避等待注入（工单 #136）
+ *
+ * 退避等待经 CheckpointContext.sleep 注入后，重试语义（尝试次数、退避序列）由记录
+ * 替身钉住，不再靠真 sleep 证明；未注入的缺省路径同时钉住「走真定时器、序列不变」。
+ */
+
+import { describe, it, expect, afterEach, jest } from '@jest/globals';
+import { CheckpointValidator } from '../checkpoint';
+import { checkHttpBody, checkHttpStatus } from '../check-handlers/http';
+import type { CheckConfig, CheckType } from '../../../types/checkpoint';
+import type { CheckpointCheck, CheckpointContext } from '../../../types/checkpoint';
+
+const realFetch = globalThis.fetch;
+
+afterEach(() => {
+  globalThis.fetch = realFetch;
+});
+
+function makeContext(overrides: Partial<CheckpointContext> = {}): CheckpointContext {
+  return { projectPath: process.cwd(), workdir: process.cwd(), ...overrides };
+}
+
+function makeCheck(id: string, type: CheckType, config: CheckConfig): CheckpointCheck {
+  return { id, type, config };
+}
+
+type InjectedSleep = NonNullable<CheckpointContext['sleep']>;
+
+/** 记录型零等待替身：记下每次退避请求的毫秒数 */
+function recordingSleep(): { waits: number[]; sleep: InjectedSleep } {
+  const waits: number[] = [];
+  const sleep: InjectedSleep = async (ms: number) => {
+    waits.push(ms);
+  };
+  return { waits, sleep };
+}
+
+/** 按脚本依次出牌的 fetch 替身：条目耗尽后重复最后一张；返回调用记录 */
+function scriptedFetch(script: Array<number | Error>): string[] {
+  const calls: string[] = [];
+  globalThis.fetch = (async (url: string | URL) => {
+    calls.push(String(url));
+    const next = script[Math.min(calls.length - 1, script.length - 1)];
+    if (next instanceof Error) throw next;
+    return new Response(null, { status: next });
+  }) as unknown as typeof fetch;
+  return calls;
+}
+
+const URL_OK = 'https://example.com';
+
+describe('http_status 重试退避（注入 sleep）', () => {
+  it('fetch 持续抛错：尝试 4 次、退避 2000/4000/6000、全程零真等待', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([new Error('Network error')]);
+
+    const startedAt = Date.now();
+    const result = await checkHttpStatus(
+      makeCheck('c-reject', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+    const elapsed = Date.now() - startedAt;
+
+    expect(elapsed).toBeLessThan(2000);
+    expect(calls).toHaveLength(4);
+    expect(waits).toEqual([2000, 4000, 6000]);
+    expect(result.passed).toBe(false);
+    expect(result.message).toContain('请求失败');
+  });
+
+  it('5xx 后恢复：尝试 2 次、只退避一次 2000', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([503, 200]);
+
+    const result = await checkHttpStatus(
+      makeCheck('c-503', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(2);
+    expect(waits).toEqual([2000]);
+    expect(result.passed).toBe(true);
+  });
+
+  it('429 后恢复：尝试 2 次、只退避一次 2000', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([429, 200]);
+
+    const result = await checkHttpStatus(
+      makeCheck('c-429', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(2);
+    expect(waits).toEqual([2000]);
+    expect(result.passed).toBe(true);
+  });
+
+  it('5xx 不恢复：退避用尽后返回最后响应，判状态码不匹配', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([500]);
+
+    const result = await checkHttpStatus(
+      makeCheck('c-500', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(4);
+    expect(waits).toEqual([2000, 4000, 6000]);
+    expect(result.passed).toBe(false);
+    expect(result.actual).toBe(500);
+    expect(result.message).toContain('不匹配');
+  });
+
+  it('404 非可重试状态码：只尝试 1 次、零退避', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([404]);
+
+    const result = await checkHttpStatus(
+      makeCheck('c-404', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(1);
+    expect(waits).toEqual([]);
+    expect(result.passed).toBe(false);
+    expect(result.message).toContain('不匹配');
+  });
+
+  it('首次即成功：不产生任何退避', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([200]);
+
+    const result = await checkHttpStatus(
+      makeCheck('c-200', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(1);
+    expect(waits).toEqual([]);
+    expect(result.passed).toBe(true);
+  });
+});
+
+describe('http_body 重试退避（注入 sleep）', () => {
+  it('fetch 持续抛错：尝试 4 次、退避 2000/4000/6000、全程零真等待', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([new Error('Network error')]);
+
+    const startedAt = Date.now();
+    const result = await checkHttpBody(
+      makeCheck('c-body-reject', 'http_body', { url: URL_OK, expected: 'test' }),
+      makeContext({ sleep })
+    );
+    const elapsed = Date.now() - startedAt;
+
+    expect(elapsed).toBeLessThan(2000);
+    expect(calls).toHaveLength(4);
+    expect(waits).toEqual([2000, 4000, 6000]);
+    expect(result.passed).toBe(false);
+    expect(result.message).toContain('请求失败');
+  });
+
+  it('响应体不含期望值：不重试、只尝试 1 次', async () => {
+    const { waits, sleep } = recordingSleep();
+    globalThis.fetch = (async () => new Response('{"data": "test"}', { status: 200 })) as unknown as typeof fetch;
+
+    const result = await checkHttpBody(
+      makeCheck('c-body-miss', 'http_body', { url: URL_OK, expected: 'NONEXISTENT' }),
+      makeContext({ sleep })
+    );
+
+    expect(waits).toEqual([]);
+    expect(result.passed).toBe(false);
+    expect(result.message).toContain('不包含');
+  });
+});
+
+describe('未注入 sleep 的缺省路径（生产行为逐字不变）', () => {
+  it('退避仍走真 setTimeout，且序列为 2000/4000/6000', async () => {
+    // 替身把 setTimeout 改成同步触发：缺省路径的「真定时器 + 退避毫秒数」一并钉住且不真等
+    // （AbortSignal.timeout 走 Node 内部计时器、不经 globalThis.setTimeout，实测收不到干扰）
+    const delays: number[] = [];
+    const spy = jest.spyOn(globalThis, 'setTimeout').mockImplementation((
+      (callback: (...args: unknown[]) => void, ms?: number) => {
+        delays.push(ms ?? 0);
+        callback();
+        return 0 as unknown as ReturnType<typeof setTimeout>;
+      }
+    ) as unknown as typeof setTimeout);
+
+    try {
+      const calls = scriptedFetch([new Error('Network error')]);
+      const startedAt = Date.now();
+      const result = await checkHttpStatus(
+        makeCheck('c-default', 'http_status', { url: URL_OK, expectedStatus: 200 }),
+        makeContext()
+      );
+      const elapsed = Date.now() - startedAt;
+
+      expect(calls).toHaveLength(4);
+      expect(delays).toEqual([2000, 4000, 6000]);
+      expect(elapsed).toBeLessThan(2000);
+      expect(result.passed).toBe(false);
+      expect(result.message).toContain('请求失败');
+    } finally {
+      spy.mockRestore();
+    }
+  });
+});
+
+describe('CheckpointValidator → http handler 的 context 接线', () => {
+  it('validate() 传入的 sleep 抵达 handler：重试全程零真等待', async () => {
+    const { waits, sleep } = recordingSleep();
+    const calls = scriptedFetch([new Error('Network error')]);
+
+    const result = await CheckpointValidator.getInstance().validate(
+      {
+        id: 'cp-wiring',
+        checks: [makeCheck('c-wiring', 'http_status', { url: URL_OK, expectedStatus: 200 })],
+      },
+      makeContext({ sleep })
+    );
+
+    expect(calls).toHaveLength(4);
+    expect(waits).toEqual([2000, 4000, 6000]);
+    expect(result.passed).toBe(false);
+    expect(result.checks[0].message).toContain('请求失败');
+  });
+});

package/src/core/validators/check-handlers/http.ts

@@ -4,34 +4,45 @@
 
 import type { CheckpointCheck, CheckResult, CheckpointContext } from '../../../types/checkpoint';
 
+/**
+ * 缺省退避等待：真定时器，生产行为
+ */
+const realSleep = (ms: number): Promise<void> => new Promise(r => setTimeout(r, ms));
+
 /**
  * HTTP 调用重试（处理 httpbin rate-limit 503/429）
+ * 等待经 sleep 注入（工单 #136）：缺省真定时器，测试注入零等待替身
  */
-async function fetchWithRetry(url: string, init?: RequestInit, retries = 3): Promise<Response> {
+async function fetchWithRetry(
+  url: string,
+  init?: RequestInit,
+  sleep: (ms: number) => Promise<void> = realSleep,
+  retries = 3
+): Promise<Response> {
   let lastError: unknown;
   for (let i = 0; i <= retries; i++) {
     try {
       const response = await fetch(url, init);
       // 5xx / 429 → 重试，指数退避
       if (!response.ok && i < retries && (response.status >= 500 || response.status === 429)) {
-        await new Promise(r => setTimeout(r, 2000 * (i + 1)));
+        await sleep(2000 * (i + 1));
         continue;
       }
       return response;
     } catch (e) {
       lastError = e;
-      if (i < retries) await new Promise(r => setTimeout(r, 2000 * (i + 1)));
+      if (i < retries) await sleep(2000 * (i + 1));
     }
   }
   throw lastError;
 }
 
-export async function checkHttpStatus(check: CheckpointCheck, _context: CheckpointContext): Promise<CheckResult> {
+export async function checkHttpStatus(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
   const url = check.config.url || '';
   const expected = check.config.expectedStatus || check.config.expected || 200;
 
   try {
-    const response = await fetchWithRetry(url, { signal: AbortSignal.timeout(10000) });
+    const response = await fetchWithRetry(url, { signal: AbortSignal.timeout(10000) }, context.sleep);
     const actual = response.status;
     const matches = actual === expected;
 
@@ -54,7 +65,7 @@ export async function checkHttpStatus(check: CheckpointCheck, _context: Checkpoi
   }
 }
 
-export async function checkHttpBody(check: CheckpointCheck, _context: CheckpointContext): Promise<CheckResult> {
+export async function checkHttpBody(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
   const url = check.config.url || '';
   const expected = String(check.config.expected || '');
 
@@ -64,7 +75,7 @@ export async function checkHttpBody(check: CheckpointCheck, _context: Checkpoint
       headers: check.config.headers,
       body: check.config.body ? JSON.stringify(check.config.body) : undefined,
       signal: AbortSignal.timeout(10000),
-    });
+    }, context.sleep);
     const actual = await response.text();
     const contains = actual.includes(expected);
 

package/src/failure/CONTEXT.md

@@ -6,7 +6,8 @@
 ## 核心导出
 - `ErrorClassifier` — 错误分类器(可配置规则)
 - `FailureRecorder` — 失败记录器(文件存储)
-- `types.ts` — 错误分类/记录类型定义
+- `index.ts` 直连类型正本 `src/types/failure.ts`（ErrorType/FailureLevel/FailureRecord/分类规则数据）
+- barrel 公开面的其余出口：`createErrorClassifier(config?)`、`classifyError(error)`（免建实例的快速分类，取 `ErrorType`）、`getFailureLevel(type)`（查 `DEFAULT_LEVEL_MAPPING`）、`createFailureRecorder(config)`（注意 config 必填，与 classifier 工厂不对称）；数据常量 `DEFAULT_FAILURE_LOG_FILE`（`.harness/logs/failures.log`）、`DEFAULT_CLASSIFICATION_RULES`、`DEFAULT_LEVEL_MAPPING` 正本同在 `src/types/failure.ts`
 
 ## 依赖关系
 - 依赖 `src/types/` 错误分类/记录类型

package/src/failure/classifier.ts

@@ -9,13 +9,13 @@ import type {
   FailureLevel,
   ErrorClassificationRule,
   ClassificationResult,
-} from './types';
+} from '../types/failure';
 import {
   ErrorType as ErrorTypeEnum,
   FailureLevel as FailureLevelEnum,
   DEFAULT_CLASSIFICATION_RULES,
   DEFAULT_LEVEL_MAPPING,
-} from './types';
+} from '../types/failure';
 
 /**
  * 错误分类器配置

package/src/failure/index.ts

@@ -5,8 +5,20 @@
  * 不包含业务逻辑
  */
 
-// 类型
-export * from './types';
+// 类型与分类数据（正本 src/types/failure.ts；harness#137 删掉 ./types 兼容 shim，
+// 本 barrel 直连正本并把星号改成显式清单——ADR-0003 的「对外给了什么」按名字可答）
+export {
+  DEFAULT_FAILURE_LOG_FILE,
+  ErrorType,
+  FailureLevel,
+  DEFAULT_CLASSIFICATION_RULES,
+  DEFAULT_LEVEL_MAPPING,
+} from '../types/failure';
+export type {
+  ErrorClassificationRule,
+  FailureRecord,
+  ClassificationResult,
+} from '../types/failure';
 
 // 分类器
 export {