@dommaker/harness 1.8.0 → 1.9.0

package/src/cli/state-io.ts

@@ -0,0 +1,53 @@
+/**
+ * 状态文件 IO 接缝（StateIO，ADR-0026 / harness#148）
+ *
+ * `.harness/.state.json` 是 harness **自身**的运行期状态（与 RunEnv 观察的项目上行
+ * 数据不是一类东西，RunEnv 保持 ADR-0023 的只读契约）。本模块是它读-改-写的唯一
+ * 入口：`check` 的智能提示与 `status` 两个写者都经本接缝，命令函数以可选参数注入，
+ * 缺省 = 真实 fs 实现（照 `CommandIO` 的注入模式，但不扩 `CommandIO`——输出面与
+ * 状态面是两个概念）。
+ *
+ * 落点 cli 层：两个消费者都在 cli，不进 core、不进包根导出面（零公共面变化）。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * `.harness/.state.json` 的具名类型（从 check.ts 内联类型提出，ADR-0026 决策 1）。
+ * `lastDiagnoseRun` 字段已删除——全仓零生产者零消费者（ADR-0022 口径）；
+ * 已落盘旧文件里残留该键无害，不做迁移。
+ */
+export interface HarnessState {
+  /** 已展示过的智能提示 id（去重依据） */
+  shownHints?: string[];
+  /** 最近一次 `harness status` 运行时刻（ISO 串） */
+  lastStatusRun?: string;
+}
+
+/** harness 自身运行期状态文件的可注入接缝（读-改-写的唯一入口） */
+export interface StateIO {
+  /** 文件缺失/空 → `{}`；损坏 → 现状语义（JSON.parse 抛即抛，不兜底，ADR-0026 决策 4） */
+  read(): HarnessState;
+  write(state: HarnessState): void;
+}
+
+/**
+ * 缺省真实 fs 实现：锚 projectPath（与 trace 落点同锚，#139），
+ * 状态文件路径知识只在本模块一份。
+ */
+export function fileStateIO(projectPath: string): StateIO {
+  const statePath = path.join(projectPath, '.harness', '.state.json');
+  return {
+    read(): HarnessState {
+      if (!fs.existsSync(statePath)) return {};
+      const content = fs.readFileSync(statePath, 'utf-8');
+      if (content.trim() === '') return {};
+      return JSON.parse(content);
+    },
+    write(state: HarnessState): void {
+      fs.mkdirSync(path.dirname(statePath), { recursive: true });
+      fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+    },
+  };
+}

package/src/hooks/CONTEXT.md

@@ -1,34 +1,24 @@
 # hooks/
 
 ## 职责
-通用 Hook 管线：注册 → 排序 → 错误隔离 → 采样执行。无业务逻辑，consumer 自行定义 hook 名称和语义。
+Harness 运行环境的组合根：一次调用装配起约束检查器、会话管理器与 trace 记录器，并加载项目配置。
 
-H5（#44）起增加两个机制（G2/G7）：
-- **注册表闭环**：`assertHookRegistryClosed(configs, hooks)` 声明（HookConfig）↔ 实现（HookDefinition）双向校验——引用未注册/注册无定义/重复均抛错，复制 checker 闭环模式；断言限构建/测试期，不进运行时热路径
-- **配置归一**：`HookConfig { name, enabled, errorStrategy }` 为 per-hook 配置唯一真相，且自 #159 起是 `enabled` / `errorStrategy` 的**唯一声明点**——`HookDefinition` 不再携带这两个字段，注册环节以配置表填充有效值（`EffectiveHook`），声明一处、读取一处，两侧矛盾在构造上不可能出现；`toErrorStrategy(blocking)` 承载 studio `blocking` → errorStrategy 的无损映射
+ADR-0027（#170）起本层只剩 bootstrap 一个面。原先的通用 hook 管线（`registry` / `pipeline` / `config` / `types` 四文件：注册 → 排序 → 错误隔离 → 采样执行）双仓零生产消费者，整体删除——裁决记录 `docs/adr/0027-hooks-pipeline-surface-trim.md`，事实前提 studio#562（studio 侧 hooks 层删除）。目录名沿用历史，不再表示「提供 hook 能力」。
 
 ## 核心导出
-- `HookRegistry` — Hook 注册表（register/registerAll/unregister/get/getEnabled/listNames/listAll/setEnabled/clear；register 以 HookConfig 填充有效值）
-- `HookPipeline` — Hook 执行管线（注册/排序/错误隔离/采样；errorStrategy block/warn）
-- `assertHookRegistryClosed` — 注册表闭环双向校验（构建/测试期）
-- `HookConfig`（type）— per-hook 配置声明（enabled / errorStrategy 唯一声明点）
-- `EffectiveHook`（type）— HookDefinition + 配置填充的有效 enabled / errorStrategy（管线与注册表判定只读它）
-- `toErrorStrategy` — blocking → errorStrategy 无损映射（G7）
-- `bootstrapHarness` / `bootstrapHarnessSync` — Harness 启动引导；也是 trace 记录器的组合根：`new ConstraintChecker(new TraceCollector({ projectPath }))`（harness#88 接线，core 不上行依赖 monitoring，故由本层接线；#139 收根：两个入口本就收 projectPath，落点随之锚定，不再取 cwd 锚定的 `getTraceCollector()` 单例）
+- `bootstrapHarness` — 异步组合根（S9：配置异步加载，不阻塞事件循环）；也是 trace 记录器的接线点：`new ConstraintChecker(new TraceCollector({ projectPath }))`（harness#88：core 不上行依赖 monitoring，故由本层接线；#139 收根：两个入口本就收 projectPath，落点随之锚定，不再取 cwd 锚定的 `getTraceCollector()` 单例）
+- `bootstrapHarnessSync` — 同形状的同步版，配置走 `readFileSync`，供不支持 top-level await 的环境与 `bootstrapHarness` 失败时的回落路径
+- `HarnessBootstrap`（type）— 返回值形状 `{ checker, sessions, projectPath, mergedConstraints }`
 
 ## 依赖关系
-- 类型正本在**本模块** `src/hooks/types.ts`（`HookPhase`/`HookErrorStrategy`/`HookConfig`/`HookDefinition`/`EffectiveHook`/`HookResult`/`PipelineResult`）；`src/types/` 里没有 hook 类型，本层只从 `src/types/project-config` 取 `MergedConstraintsConfig` 类型
-- 向下依赖（仅 `bootstrap.ts` 组合根）：`core/constraints/checker`、`core/project-config-loader`、`context/session-manager`、`monitoring/traces`——`registry/pipeline/config/types` 四文件零上层依赖，是纯管线
-- 消费方：包根 `src/index.ts` 的 `./hooks` 出口与下游项目（studio 的 hook 装配）。**harness 内部无生产消费方**——core/cli 侧的调用边已随零消费者清账删除（harness#141 同判据，ADR-0022），「被 core 核心引擎/CLI 初始化流程消费」的旧说法已失效（harness#142 核对）
+- 向下依赖：`core/constraints/checker`、`core/project-config-loader`、`context/session-manager`、`monitoring/traces`；类型面只从 `src/types/project-config` 取 `MergedConstraintsConfig`
+- 消费方：包根 `src/index.ts` 的 bootstrap 三符号出口，与下游项目的运行环境初始化。生产唯一调用方是 studio（经 studio-shared `runtime/bootstrap.ts`，**无参调用**、只以类型持有 `HarnessBootstrap`）。**harness 内部无生产消费方**——core/cli 侧的调用边已随零消费者清账删除（harness#141 同判据，ADR-0022）
 
 ## 约定
-- 无业务逻辑，只提供管线能力
-- Consumer 自行定义 hook 名称和触发时机
-- **闭环**：声明配置与注册实现必须一一对应，缺一抛错（消灭「hook 定义不注册 = 死代码」类人记规矩）
-- **映射语义**：blocking=true → 'block'（失败阻断管线，停止后续 hook、passed=false）；blocking=false → 'warn'（记录警告继续）；有效策略集合仅 'block' | 'warn'（#159 起原 'ignore' 与「未声明 strategy」形态退出有效面——策略由 HookConfig 必填声明）
-- 错误隔离：单个 hook 失败不影响其他 hook
+- 参数面只有 `projectPath`（缺省 `process.cwd()`）：不给 hook 定义、不给配置表，`hookDefinitions` / `hookConfigs` 与注册闭环语义随管线面一同退场
+- 组合根只做装配不做判定，`mergedConstraints` 原样透出，用不用由调用方决定
+- 本层无内置 hook 定义，也不再提供 hook 管线能力；provider 侧的 PreToolUse 执法入口是 `src/pretool-use-hook.ts`（门禁 CLI 的另一条路），与本目录无关
 
 ## 注意事项
-- 通用管线设计，不绑定特定生命周期
-- 采样执行用于高频 hook(减少性能影响)
-- 闭环断言是纯函数，由 consumer 在其注册点/测试中调用；harness 无内置 hook 定义，不自动断言
+- 无 unload/dispose：`SessionManager` 与 `TraceCollector` 随进程生命周期，本层不提供逆操作（口径同 `src/CONTEXT.md` 术语「文件驱动 CLI」）
+- 删除属公共面 breaking：包根不再可达的符号有 4 个值符号（注册表、管线、闭环断言、blocking 映射）与 8 个类型，迁移路径 = 删引用；可达性负钉在 `src/__tests__/public-exports.test.ts`，两道全量清单闸（`public-exports` / `public-type-surface`）的条目已同步收缩

package/src/hooks/__tests__/bootstrap.test.ts

@@ -5,17 +5,17 @@
  * bootstrapHarnessSync uses synchronous fs reads and is more straightforward.
  *
  * Uses temp directories to provide harness config.
+ *
+ * ADR-0027（#170）：hooks 管线面删除后本层只剩组合根职责——加载项目配置、
+ * 装配 checker / SessionManager / TraceCollector。`hookDefinitions` / `hookConfigs`
+ * 两参数与 `hooks` / `pipeline` 两字段随之消失，形状由编译期 + 运行期双钉冻结
+ * （手法照 ADR-0022 对 AC-007 的改写）。
  */
 
 import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'js-yaml';
 import { bootstrapHarnessSync, bootstrapHarness } from '../bootstrap';
-import type { HookConfig, HookDefinition } from '../types';
-
-function makeHookConfig(name: string, overrides: Partial<HookConfig> = {}): HookConfig {
-  return { name, enabled: true, errorStrategy: 'warn', ...overrides };
-}
 
 function setupTempDir(dir: string): string {
   const harnessDir = path.join(dir, '.harness');
@@ -28,6 +28,16 @@ function setupTempDir(dir: string): string {
   return harnessDir;
 }
 
+/** 已删字段的编译期钉：回灌（重新声明该字段）即 TS2578 红。纯读，不产生任何落盘副作用。 */
+function assertPipelineSurfaceUnreachable(result: ReturnType<typeof bootstrapHarnessSync>): void {
+  // @ts-expect-error hooks 字段随 ADR-0027 管线面删除
+  const gone = result.hooks;
+  expect(gone).toBeUndefined();
+  // @ts-expect-error pipeline 字段随 ADR-0027 管线面删除
+  const gone2 = result.pipeline;
+  expect(gone2).toBeUndefined();
+}
+
 describe('bootstrapHarness', () => {
   let tempDir: string;
 
@@ -44,10 +54,11 @@ describe('bootstrapHarness', () => {
     const result = await bootstrapHarness(tempDir);
     expect(result).toHaveProperty('checker');
     expect(result).toHaveProperty('sessions');
-    expect(result).toHaveProperty('hooks');
-    expect(result).toHaveProperty('pipeline');
     expect(result).toHaveProperty('projectPath', tempDir);
     expect(result).toHaveProperty('mergedConstraints');
+    expect(Object.keys(result).sort()).toEqual(
+      ['checker', 'mergedConstraints', 'projectPath', 'sessions'],
+    );
   });
 
   it('initializes with the provided project path', async () => {
@@ -55,33 +66,8 @@ describe('bootstrapHarness', () => {
     expect(result.projectPath).toBe(tempDir);
   });
 
-  it('registers hook definitions when provided (with configs)', async () => {
-    const hookDef: HookDefinition = {
-      name: 'async-hook',
-      phase: 'before',
-      execute: async () => ({ passed: true }),
-    };
-    const result = await bootstrapHarness(tempDir, [hookDef], [makeHookConfig('async-hook')]);
-    expect(result.hooks.listNames()).toContain('async-hook');
-    expect(result.hooks.get('async-hook')?.errorStrategy).toBe('warn');
-  });
-
-  it('throws when definitions are provided without configs (#159)', async () => {
-    const hookDef: HookDefinition = {
-      name: 'async-hook',
-      phase: 'before',
-      execute: async () => ({ passed: true }),
-    };
-    await expect(bootstrapHarness(tempDir, [hookDef])).rejects.toThrow(/HookConfig/);
-  });
-
-  it('does not register hooks when no definitions provided', async () => {
-    const result = await bootstrapHarness(tempDir, []);
-    expect(result.hooks.listNames()).toEqual([]);
-  });
-
   it('uses process.cwd() when no project path is given', async () => {
-    const result = await bootstrapHarness(undefined, []);
+    const result = await bootstrapHarness();
     expect(result).toHaveProperty('projectPath');
     expect(result.projectPath).toBeDefined();
   });
@@ -122,10 +108,9 @@ describe('bootstrapHarnessSync', () => {
     const result = bootstrapHarnessSync(tempDir);
     expect(result).toHaveProperty('checker');
     expect(result).toHaveProperty('sessions');
-    expect(result).toHaveProperty('hooks');
-    expect(result).toHaveProperty('pipeline');
     expect(result).toHaveProperty('projectPath', tempDir);
     expect(result).toHaveProperty('mergedConstraints');
+    assertPipelineSurfaceUnreachable(result);
   });
 
   it('initializes with the provided project path', () => {
@@ -140,34 +125,10 @@ describe('bootstrapHarnessSync', () => {
     expect(result.mergedConstraints).toHaveProperty('guidelines');
   });
 
-  it('registers hook definitions when provided (with configs)', () => {
-    const hookDef: HookDefinition = {
-      name: 'test-hook',
-      phase: 'before',
-      execute: async () => ({ passed: true }),
-    };
-    const result = bootstrapHarnessSync(tempDir, [hookDef], [makeHookConfig('test-hook')]);
-    expect(result.hooks.listNames()).toContain('test-hook');
-  });
-
-  it('throws when definitions are provided without configs (#159)', () => {
-    const hookDef: HookDefinition = {
-      name: 'test-hook',
-      phase: 'before',
-      execute: async () => ({ passed: true }),
-    };
-    expect(() => bootstrapHarnessSync(tempDir, [hookDef])).toThrow(/HookConfig/);
-  });
-
-  it('does not register hooks when no definitions provided', () => {
-    const result = bootstrapHarnessSync(tempDir, []);
-    expect(result.hooks.listNames()).toEqual([]);
-  });
-
   it('uses process.cwd() when no project path is given', () => {
     // We cannot easily test process.cwd() fallback without mocking cwd,
     // but we can verify the function accepts undefined
-    const result = bootstrapHarnessSync(undefined, []);
+    const result = bootstrapHarnessSync(undefined);
     // Should not throw with process.cwd() — harness directory may not exist
     expect(result).toHaveProperty('projectPath');
     expect(result.projectPath).toBeDefined();
@@ -182,16 +143,6 @@ describe('bootstrapHarnessSync', () => {
     expect(fs.existsSync(sessionDir)).toBe(true);
   });
 
-  it('creates a working HookPipeline', () => {
-    const hookDef: HookDefinition = {
-      name: 'pipeline-hook',
-      phase: 'after',
-      execute: async () => ({ passed: true, data: 'ok' }),
-    };
-    const result = bootstrapHarnessSync(tempDir, [hookDef], [makeHookConfig('pipeline-hook')]);
-    expect(result.pipeline).toBeDefined();
-  });
-
   it('loads from .harness/config.yml when present', () => {
     // Write a custom config with specific settings
     const harnessDir = path.join(tempDir, '.harness');

package/src/hooks/bootstrap.ts

@@ -8,21 +8,22 @@
  * Consumer 用法：
  * ```typescript
  * const harness = await bootstrapHarness('/path/to/project');
- * // harness.checker, harness.config, harness.hooks, harness.sessions
+ * // harness.checker, harness.sessions, harness.mergedConstraints
  * ```
  *
  * checker 的 trace 记录器在此接线（harness#88：core 不上行依赖 monitoring），
  * 且锚在本函数收到的 projectPath 上（#139：落点跟根走，不落调用方 cwd）。
+ *
+ * ADR-0027（#170）：hooks 管线面（registry/pipeline/config/types）双仓零生产消费者，
+ * 整体删除；本层的 `hookDefinitions` / `hookConfigs` 两参数与 `hooks` / `pipeline`
+ * 两字段随之消失——生产唯一调用方本就无参调用、不访问被删字段。
  */
 
 import { ConstraintChecker } from '../core/constraints/checker';
 import { SessionManager } from '../context/session-manager';
 import { ProjectConfigLoader } from '../core/project-config-loader';
 import { TraceCollector } from '../monitoring/traces';
-import { HookRegistry } from './registry';
-import { HookPipeline } from './pipeline';
 import type { MergedConstraintsConfig } from '../types/project-config';
-import type { HookConfig, HookDefinition } from './types';
 
 /**
  * 异步加载项目配置（S9：异步 I/O）
@@ -50,46 +51,19 @@ export interface HarnessBootstrap {
   checker: ConstraintChecker;
   /** 会话管理器 */
   sessions: SessionManager;
-  /** Hook 注册表 */
-  hooks: HookRegistry;
-  /** Hook 管线 */
-  pipeline: HookPipeline;
   /** 项目路径 */
   projectPath: string;
   /** 合并后的约束配置 */
   mergedConstraints: MergedConstraintsConfig;
 }
 
-/**
- * 注册初始 hook（定义必须配对配置声明表——#159 起 HookConfig 是
- * enabled / errorStrategy 的唯一声明点，缺表即抛错）
- */
-function registerInitialHooks(
-  hooks: HookRegistry,
-  hookDefinitions: HookDefinition[] | undefined,
-  hookConfigs: HookConfig[] | undefined
-): void {
-  if (!hookDefinitions || hookDefinitions.length === 0) return;
-  if (!hookConfigs) {
-    throw new Error(
-      '[harness] bootstrap 失败：注册 hook 定义必须同时提供 HookConfig 声明表' +
-      '（enabled / errorStrategy 的唯一声明点）。'
-    );
-  }
-  hooks.registerAll(hookDefinitions, hookConfigs);
-}
-
 /**
  * 初始化 harness 运行环境（异步，不阻塞事件循环）
  *
  * @param projectPath 项目根路径
- * @param hookDefinitions 可选，初始化时注册的 hook
- * @param hookConfigs 可选，与 hookDefinitions 配对的配置声明表（注册定义时必填）
  */
 export async function bootstrapHarness(
-  projectPath?: string,
-  hookDefinitions?: HookDefinition[],
-  hookConfigs?: HookConfig[]
+  projectPath?: string
 ): Promise<HarnessBootstrap> {
   const resolvedPath = projectPath || process.cwd();
 
@@ -101,17 +75,10 @@ export async function bootstrapHarness(
   const checker = new ConstraintChecker(new TraceCollector({ projectPath: resolvedPath }));
 
   const sessions = new SessionManager(resolvedPath);
-  const hooks = new HookRegistry();
-  const pipeline = new HookPipeline(hooks);
-
-  // 3. 注册初始 hook
-  registerInitialHooks(hooks, hookDefinitions, hookConfigs);
 
   return {
     checker,
     sessions,
-    hooks,
-    pipeline,
     projectPath: resolvedPath,
     mergedConstraints,
   };
@@ -121,11 +88,11 @@ export async function bootstrapHarness(
  * 同步 bootstrap（兼容不支持 top-level await 的环境）
  *
  * 配置加载仍为同步（readFileSync），其他组件初始化同上。
+ *
+ * @param projectPath 项目根路径
  */
 export function bootstrapHarnessSync(
-  projectPath?: string,
-  hookDefinitions?: HookDefinition[],
-  hookConfigs?: HookConfig[]
+  projectPath?: string
 ): HarnessBootstrap {
   const resolvedPath = projectPath || process.cwd();
 
@@ -136,16 +103,10 @@ export function bootstrapHarnessSync(
   const checker = new ConstraintChecker(new TraceCollector({ projectPath: resolvedPath }));
 
   const sessions = new SessionManager(resolvedPath);
-  const hooks = new HookRegistry();
-  const pipeline = new HookPipeline(hooks);
-
-  registerInitialHooks(hooks, hookDefinitions, hookConfigs);
 
   return {
     checker,
     sessions,
-    hooks,
-    pipeline,
     projectPath: resolvedPath,
     mergedConstraints,
   };

package/src/hooks/index.ts

@@ -1,25 +1,10 @@
 /**
  * Hooks 模块
  *
- * 通用 hook 管线：注册 → 排序 → 错误隔离 → 采样执行。
- * 无业务逻辑，consumer 自行定义 hook 名称和语义。
+ * ADR-0027（#170）起本层只剩 `bootstrap.ts` 一个面：通用 hook 管线
+ * （registry / pipeline / config / types 四文件）双仓零生产消费者，整体删除。
+ * 目录名沿用历史，职责是 harness 运行环境的组合根。
  */
 
-export type {
-  HookPhase,
-  HookErrorStrategy,
-  HookConfig,
-  HookDefinition,
-  EffectiveHook,
-  HookResult,
-  HookExecutionRecord,
-  PipelineResult,
-} from './types';
-export { HookRegistry, assertHookRegistryClosed } from './registry';
-export { HookPipeline } from './pipeline';
-export { toErrorStrategy } from './config';
-export {
-  bootstrapHarness,
-  bootstrapHarnessSync,
-  type HarnessBootstrap,
-} from './bootstrap';
+export { bootstrapHarness, bootstrapHarnessSync } from './bootstrap';
+export type { HarnessBootstrap } from './bootstrap';

package/src/index.ts

@@ -342,25 +342,13 @@ export { getCriticalArtifacts, verifyReleaseArtifacts } from './release';
 export type { ArtifactIntegrityResult } from './release';
 
 // ========================================
-// Hooks 管线
+// Harness 运行环境引导（bootstrap 单面；hooks 管线面已随 ADR-0027 删除）
 // ========================================
 export {
-  HookRegistry,
-  assertHookRegistryClosed,
-  HookPipeline,
-  toErrorStrategy,
   bootstrapHarness,
   bootstrapHarnessSync,
 } from './hooks';
 export type {
-  HookDefinition,
-  HookConfig,
-  EffectiveHook,
-  HookErrorStrategy,
-  HookExecutionRecord,
-  HookPhase,
-  HookResult,
-  PipelineResult,
   HarnessBootstrap,
 } from './hooks';
 

package/dist/hooks/config.d.ts

@@ -1,30 +0,0 @@
-/**
- * Hook 配置归一（G7）
- *
- * studio 侧 per-hook 运行时配置（`blocking: boolean`）与 harness 侧
- * `HookConfig.errorStrategy` 双轨归一：以 errorStrategy 为唯一真相，
- * `blocking` → errorStrategy 为无损映射。
- *
- * 映射语义（确认于 H5）：
- * - blocking=true  → 'block'：hook 失败阻断管线（停止执行后续 hook，
- *   管线结果 passed=false、blockedBy 记名）——对应 studio safeCallHook 抛错
- * - blocking=false → 'warn'：hook 失败记录警告并继续执行后续 hook
- *   （管线结果 warnings 记名，passed 不受影响）——对应 studio safeCallHook
- *   console.warn 继续
- *
- * #159 起 `HookConfig` 是 `enabled` / `errorStrategy` 的唯一声明点：
- * HookDefinition 不再携带这两个字段，注册环节以配置表填充有效值，
- * 有效策略集合收敛为 'block' | 'warn'（原 'ignore' 退出有效面）。
- *
- * studio 侧随动（studio #150 A4）：hooks/config.ts 删 DEFAULTS/safeCallHook，
- * blocking→errorStrategy 无损映射进 toHookDef；HARNESS_HOOK_DISABLE 保留 studio。
- */
-import type { HookErrorStrategy } from './types';
-/**
- * blocking 布尔 → errorStrategy 无损映射（block/warn）
- *
- * @param blocking studio 侧「失败是否阻断」语义
- * @returns 'block'（阻断）| 'warn'（警告继续）
- */
-export declare function toErrorStrategy(blocking: boolean): HookErrorStrategy;
-//# sourceMappingURL=config.d.ts.map

package/dist/hooks/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/hooks/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,iBAAiB,CAEpE"}

package/dist/hooks/config.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Hook 配置归一（G7）
- *
- * studio 侧 per-hook 运行时配置（`blocking: boolean`）与 harness 侧
- * `HookConfig.errorStrategy` 双轨归一：以 errorStrategy 为唯一真相，
- * `blocking` → errorStrategy 为无损映射。
- *
- * 映射语义（确认于 H5）：
- * - blocking=true  → 'block'：hook 失败阻断管线（停止执行后续 hook，
- *   管线结果 passed=false、blockedBy 记名）——对应 studio safeCallHook 抛错
- * - blocking=false → 'warn'：hook 失败记录警告并继续执行后续 hook
- *   （管线结果 warnings 记名，passed 不受影响）——对应 studio safeCallHook
- *   console.warn 继续
- *
- * #159 起 `HookConfig` 是 `enabled` / `errorStrategy` 的唯一声明点：
- * HookDefinition 不再携带这两个字段，注册环节以配置表填充有效值，
- * 有效策略集合收敛为 'block' | 'warn'（原 'ignore' 退出有效面）。
- *
- * studio 侧随动（studio #150 A4）：hooks/config.ts 删 DEFAULTS/safeCallHook，
- * blocking→errorStrategy 无损映射进 toHookDef；HARNESS_HOOK_DISABLE 保留 studio。
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.toErrorStrategy = toErrorStrategy;
-/**
- * blocking 布尔 → errorStrategy 无损映射（block/warn）
- *
- * @param blocking studio 侧「失败是否阻断」语义
- * @returns 'block'（阻断）| 'warn'（警告继续）
- */
-function toErrorStrategy(blocking) {
-    return blocking ? 'block' : 'warn';
-}
-//# sourceMappingURL=config.js.map

package/dist/hooks/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","sourceRoot":"","sources":["../../src/hooks/config.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;AAUH,0CAEC;AARD;;;;;GAKG;AACH,SAAgB,eAAe,CAAC,QAAiB;IAC/C,OAAO,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC"}

package/dist/hooks/pipeline.d.ts

@@ -1,36 +0,0 @@
-/**
- * HookPipeline — hook 有序执行、错误隔离、采样
- *
- * 执行顺序：before hooks → consumer operation → after hooks
- * 每个 hook 独立 try/catch，单个 hook 失败不影���其他 hook。
- */
-import type { HookPhase, PipelineResult } from './types';
-import type { HookRegistry } from './registry';
-export declare class HookPipeline<C = unknown> {
-    private registry;
-    constructor(registry: HookRegistry<C, unknown>);
-    /**
-     * 执行指定 phase 的所有 enabled hook
-     *
-     * @param phase hook 时机
-     * @param context 传递给每个 hook 的上下文
-     * @returns 管线执行结果
-     */
-    run(phase: HookPhase, context: C): Promise<PipelineResult>;
-    /**
-     * 执行 before + after 全套管线
-     *
-     * @param context 上下文
-     * @param operation 业务操作（在 before 和 after 之间执行）
-     * @returns 管线结果 + 操作结果
-     */
-    runFull<R>(context: C, operation: () => Promise<R>): Promise<{
-        pipelineResult: PipelineResult;
-        operationResult?: R;
-    }>;
-    /**
-     * 执行单个 hook（带采样和错误隔离）
-     */
-    private executeOne;
-}
-//# sourceMappingURL=pipeline.d.ts.map

package/dist/hooks/pipeline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/hooks/pipeline.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAEV,SAAS,EAET,cAAc,EACf,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO;IACnC,OAAO,CAAC,QAAQ,CAA2B;gBAE/B,QAAQ,EAAE,YAAY,CAAC,CAAC,EAAE,OAAO,CAAC;IAI9C;;;;;;OAMG;IACG,GAAG,CACP,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,cAAc,CAAC;IAyB1B;;;;;;OAMG;IACG,OAAO,CAAC,CAAC,EACb,OAAO,EAAE,CAAC,EACV,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAC1B,OAAO,CAAC;QAAE,cAAc,EAAE,cAAc,CAAC;QAAC,eAAe,CAAC,EAAE,CAAC,CAAA;KAAE,CAAC;IAwCnE;;OAEG;YACW,UAAU;CA4CzB"}