@dommaker/harness 1.8.1 → 1.9.0

package/src/cli/commands/sync-docs/capabilities-syncer.ts

@@ -54,12 +54,22 @@ export async function updateCapabilitiesFile(
 
   // 如果有表格行，更新表格
   if (existingFiles.length > 0) {
-    // 移除已删除文件的行
-    for (const removed of result.removed) {
-      const escapedFile = removed.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      // 第二列存完整路径，basename 只在末尾出现，用 [^|]* 匹配路径前缀
-      const rowRegex = new RegExp(`^\\|[^|]*\\|[^|]*\\b${escapedFile}\\s*\\|.*$`, 'gm');
-      content = content.replace(rowRegex, '');
+    // 移除已删除文件的行（整行连行尾一起删——只清行内容会留一个空行，
+    // CommonMark 据此把一张表切成若干小表，harness#171）。
+    // 这里**不**豁免围栏代码块，与下方排版收拢刻意不同口径：登记条目由
+    // capabilities-parser 全文扫描得出（ADR-0009），围栏内的行同样算登记项；
+    // 只让删除认围栏而条目不认，块内示例行会一直被解析成幽灵条目，`--check`
+    // 从此每轮都报同一个已删文件且永远修不掉。豁免要生效得连登记面一起改。
+    if (result.removed.length > 0) {
+      const deadRowRegexes = result.removed.map((removed) => {
+        const escapedFile = removed.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // 第二列存完整路径，basename 只在末尾出现，用 [^|]* 匹配路径前缀
+        return new RegExp(`^\\|[^|]*\\|[^|]*\\b${escapedFile}\\s*\\|.*\\r?$`);
+      });
+      content = content
+        .split('\n')
+        .filter((line) => !deadRowRegexes.some((rowRegex) => rowRegex.test(line)))
+        .join('\n');
     }
 
     // 添加新文件的行（在最后一个表格行之后）；module 模式跳过
@@ -80,14 +90,17 @@ export async function updateCapabilitiesFile(
         content = content.replace(lastTableRow, lastTableRow + '\n' + newRows);
       }
     }
-
-    // 清理多余空行
-    content = content.replace(/\n{3,}/g, '\n\n');
   } else {
     // 没有表格，追加模块表格（module 模式按目录聚合）
     content += '\n\n' + (mode === 'module' ? generateDirTable(currentModules) : generateModuleTable(currentModules));
   }
 
+  // 表格排版收拢放在增删之后：有新行的表不会被误判为空表（#171）
+  content = normalizeCapabilitiesTableLayout(content).content;
+  // 多余空行的清理收在收拢之后一处：收拢本身会新产出连续空行
+  // （收掉一张夹在两段散文之间的空表就留下 `\n\n\n`，#171）
+  content = content.replace(/\n{3,}/g, '\n\n');
+
   // 更新最后更新时间
   const now = new Date().toISOString().split('T')[0];
   content = content.replace(
@@ -98,6 +111,123 @@ export async function updateCapabilitiesFile(
   await fs.writeFile(capabilitiesPath, content, 'utf-8');
 }
 
+/** 表格行：以 `|` 起始（表头、分隔行、数据行都算） */
+const TABLE_ROW_REGEX = /^\s*\|/;
+
+/** 表格分隔行（|------|------|） */
+const TABLE_SEPARATOR_REGEX = /^\s*\|[\s:|-]+\|\s*$/;
+
+/** 围栏代码块的起止行（``` / ~~~，允许缩进与信息串） */
+const FENCE_LINE_REGEX = /^\s*(?:```|~~~)/;
+
+export interface TableLayoutNormalization {
+  /** 收拢后的内容 */
+  content: string;
+  /** 被删掉的「表格内空行」行数 */
+  blankLines: number;
+  /** 被收掉的「空表」（表头+分隔行且无数据行）张数 */
+  emptyTables: number;
+}
+
+/** 参与排版判定的行：正文 + 是否落在围栏代码块内 */
+interface LayoutLine {
+  text: string;
+  fenced: boolean;
+}
+
+/**
+ * 按行切开并标出围栏代码块（``` / ~~~）内的行
+ *
+ * 只服务排版收拢：CAPABILITIES.md 是手写文档，块内长得像表格的示例行不是排版脏行，
+ * 收它就是删用户正文（harness#171）。登记条目面不在此列——见 `updateCapabilitiesFile`
+ * 里「幽灵行删除不豁免围栏」的取舍注释。
+ */
+function parseLayoutLines(content: string): LayoutLine[] {
+  const parsed: LayoutLine[] = [];
+  let inFence = false;
+  for (const text of content.split('\n')) {
+    if (FENCE_LINE_REGEX.test(text)) {
+      parsed.push({ text, fenced: true });
+      inFence = !inFence;
+      continue;
+    }
+    parsed.push({ text, fenced: inFence });
+  }
+  return parsed;
+}
+
+const isTableRow = (line: LayoutLine | undefined): line is LayoutLine =>
+  line !== undefined && !line.fenced && TABLE_ROW_REGEX.test(line.text);
+
+const isTableSeparator = (line: LayoutLine | undefined): boolean =>
+  line !== undefined && !line.fenced && TABLE_SEPARATOR_REGEX.test(line.text);
+
+/** 走一遍两条收拢规则（不迭代） */
+function collapseTableLayoutOnce(content: string): TableLayoutNormalization {
+  const parsed = parseLayoutLines(content);
+
+  // ① 收拢表格内空行：一段连续空行，两侧最近非空行都是表格行 → 整段丢弃
+  const kept: LayoutLine[] = [];
+  let blankLines = 0;
+  for (let i = 0; i < parsed.length; ) {
+    if (parsed[i].text.trim() !== '') {
+      kept.push(parsed[i]);
+      i++;
+      continue;
+    }
+    let end = i;
+    while (end < parsed.length && parsed[end].text.trim() === '') end++;
+    if (isTableRow(kept[kept.length - 1]) && isTableRow(parsed[end])) {
+      blankLines += end - i;
+    } else {
+      kept.push(...parsed.slice(i, end));
+    }
+    i = end;
+  }
+
+  // ② 收掉空表：表头 + 分隔行后面没有数据行
+  const out: string[] = [];
+  let emptyTables = 0;
+  for (let i = 0; i < kept.length; i++) {
+    if (isTableRow(kept[i]) && isTableSeparator(kept[i + 1]) && !isTableRow(kept[i + 2])) {
+      emptyTables++;
+      i++;
+      continue;
+    }
+    out.push(kept[i].text);
+  }
+
+  return { content: out.join('\n'), blankLines, emptyTables };
+}
+
+/**
+ * 收拢 CAPABILITIES.md 的表格排版（harness#171）
+ *
+ * 两条规则：① 删掉夹在两个表格行之间的空行（CommonMark 会在此切断表格）；
+ * ② 收掉没有数据行的表头+分隔行。表格外的空行（段落分隔）不动；围栏代码块内的行整体豁免。
+ *
+ * 规则互相制造对方的触发点（①把两张空表之间的那个空行吃掉后，②一轮只收得掉后一张），
+ * 所以跑到不动点：**一次 `sync-docs` 必须把 `--check` 报出来的东西全清掉**，
+ * 否则下游 CI 修完还是红的。计数 = 各轮合计（每轮只删当轮存在的行，不会重计）。
+ *
+ * 幂等，且 `--check` 与写模式共用此正本——判定面就是「返回内容与入参是否不同」，
+ * 因此不存在「check 报了 fix 修不掉」的不收敛（ADR-0009 口径）。
+ */
+export function normalizeCapabilitiesTableLayout(content: string): TableLayoutNormalization {
+  let current = content;
+  let blankLines = 0;
+  let emptyTables = 0;
+  for (;;) {
+    const pass = collapseTableLayoutOnce(current);
+    if (pass.blankLines === 0 && pass.emptyTables === 0) {
+      return { content: current, blankLines, emptyTables };
+    }
+    blankLines += pass.blankLines;
+    emptyTables += pass.emptyTables;
+    current = pass.content;
+  }
+}
+
 /**
  * 生成 CAPABILITIES.md 内容
  */

package/src/cli/commands/sync-docs/index.ts

@@ -34,6 +34,7 @@ import {
   parseCapabilitiesFiles,
   updateCapabilitiesFile,
   compactCapabilitiesContent,
+  normalizeCapabilitiesTableLayout,
 } from './capabilities-syncer';
 import {
   createContextMd,
@@ -264,7 +265,15 @@ export async function syncDocs(
   }
   const hasAgentsIssues = options.agents === true && agentsMdStale;
 
-  const hasTableIssues = result.added.length > 0 || result.removed.length > 0;
+  // 表格排版脏行（#171）：撤登记时残留的空行会把 CAPABILITIES.md 的表格切断。
+  // 判定与修复共用 normalizeCapabilitiesTableLayout 正本——同一份规则，check 报的 fix 必清得掉。
+  const tableLayout = capsIsCapabilityListing
+    ? { blankLines: 0, emptyTables: 0 }
+    : normalizeCapabilitiesTableLayout(capsContent);
+  const hasTableLayoutIssues = tableLayout.blankLines > 0 || tableLayout.emptyTables > 0;
+
+  const hasTableEntryIssues = result.added.length > 0 || result.removed.length > 0;
+  const hasTableIssues = hasTableEntryIssues || hasTableLayoutIssues;
   const hasCapIssues = capCountMismatches.length > 0;
   // mtime 只作提示，不参与判定（harness#142）：判定面是内容漂移与缺失
   const hasContextIssues = result.contextMissing.length > 0 || result.contextContentDrift.length > 0;
@@ -287,6 +296,7 @@ export async function syncDocs(
         contextMissing: result.contextMissing.length,
         contextStale: result.contextStale.length,
         contextContentDrift: result.contextContentDrift.length,
+        tableLayoutDirty: hasTableLayoutIssues,
       },
       contextMissing: result.contextMissing.map(d => ({
         dir: d,
@@ -314,7 +324,7 @@ export async function syncDocs(
       });
     }
 
-    if (!capsIsCapabilityListing && hasTableIssues) {
+    if (!capsIsCapabilityListing && hasTableEntryIssues) {
       if (capsMode === 'module') {
         // module 模式：added 为聚合后的未覆盖目录，需人工登记目录条目
         jsonOutput.added = result.added.map(d => ({ dir: d }));
@@ -341,6 +351,19 @@ export async function syncDocs(
       }
     }
 
+    if (hasTableLayoutIssues) {
+      jsonOutput.tableLayout = {
+        blankLines: tableLayout.blankLines,
+        emptyTables: tableLayout.emptyTables,
+      };
+      (jsonOutput.resolution as Array<Record<string, unknown>>).push({
+        action: 'sync-capabilities-table-layout',
+        command: 'harness sync-docs',
+        details:
+          'CAPABILITIES.md 的表格被空行切断、或残留无数据行的空表头，运行 harness sync-docs 收拢',
+      });
+    }
+
     if (hasContextIssues) {
       (jsonOutput.resolution as Array<Record<string, unknown>>).push(
         ...(result.contextMissing.length > 0
@@ -400,6 +423,16 @@ export async function syncDocs(
     result.removed.forEach(f => log(io, chalk.gray(`  - ${f}`)));
   }
 
+  if (hasTableLayoutIssues) {
+    log(io, chalk.yellow(`\n🧹 CAPABILITIES.md 表格排版待收拢:`));
+    if (tableLayout.blankLines > 0) {
+      log(io, chalk.gray(`  - 表格内空行 ${tableLayout.blankLines} 处（CommonMark 会在此把表格切断）`));
+    }
+    if (tableLayout.emptyTables > 0) {
+      log(io, chalk.gray(`  - 无数据行的空表 ${tableLayout.emptyTables} 张（连表头/分隔行一起收掉）`));
+    }
+  }
+
   if (result.contextMissing.length > 0) {
     log(io, chalk.yellow(`\n📋 缺少 CONTEXT.md:`));
     result.contextMissing.forEach(d => log(io, chalk.gray(`  - ${d}/CONTEXT.md`)));
@@ -450,10 +483,14 @@ export async function syncDocs(
   if (isCheck) {
     log(io, chalk.red('\n❌ 文档不是最新的，请运行 harness sync-docs 更新'));
     // reason 必须可定位（harness#142）：CI 判红时要直接拿到文件与符号，不靠翻 stdout
+    const tableLayoutReason = hasTableLayoutIssues
+      ? `；CAPABILITIES.md 表格排版待收拢（表格内空行 ${tableLayout.blankLines} 处、`
+        + `空表 ${tableLayout.emptyTables} 张）`
+      : '';
     return drift(
       contextDriftReason
-        ? `文档不是最新的（CONTEXT.md 与实现漂移：${contextDriftReason}）`
-        : '文档不是最新的，请运行 harness sync-docs 更新'
+        ? `文档不是最新的（CONTEXT.md 与实现漂移：${contextDriftReason}）${tableLayoutReason}`
+        : `文档不是最新的，请运行 harness sync-docs 更新${tableLayoutReason}`
     );
   }
 

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；`run(phase)` 时机粒度、`runFull` 全套、`runOne(name)` 按名执行单个 hook——#167 新增：enabled:false 返回 skipped:true 记录且实现体零调用，block 失败抛错 / warn 失败返回 passed:false 记录，未知名抛错（口径同注册表闭环），采样与错误隔离复用 executeOne 单路径）
-- `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';