@dommaker/harness 0.19.0 → 1.0.0

package/src/gates/types.ts

@@ -3,7 +3,10 @@
  */
 
 /**
- * 门禁结果
+ * 门禁结果（报告结构，保留）
+ *
+ * 统一 Gate 接口后 GateResult 仍是每个门禁产出的报告层；
+ * 决策层见 GateDecision。
  */
 export interface GateResult {
   gate: string;
@@ -14,6 +17,44 @@ export interface GateResult {
   duration?: number;
 }
 
+/**
+ * 门禁决策三态（守卫/门禁统一，G1）
+ *
+ * - deny：阻断。单调语义——一旦出现，下游门禁不得改回 allow。
+ * - abstain：弃权/放行。不阻断，也不否决。
+ * - ask：需要人裁决。枚举预留，暂无实现；无实现时 fail-closed 按 deny 计。
+ */
+export type GateDecisionStatus = 'deny' | 'abstain' | 'ask';
+
+/**
+ * 门禁决策：统一 Gate 接口的返回值
+ *
+ * status 是三态决策；result 携带 GateResult 报告结构。
+ * 决策对象由 decisionFromResult / runGates 浅冻结——不可变是
+ * deny 单调语义的接口契约。
+ */
+export interface GateDecision {
+  /** 三态决策 */
+  status: GateDecisionStatus;
+  /** 报告结构（GateResult 保留为报告层，不删） */
+  result: GateResult;
+}
+
+/**
+ * 统一门禁接口（G1）
+ *
+ * 统一的是决策协议（id / 声明式 order / evaluate → 三态决策），
+ * 各门禁执行细节（gh pr view / 正则黑名单 / OpenAPI diff / benchmark…）私有。
+ */
+export interface Gate {
+  /** 门禁 id（与 gates/definitions.ts 定义一致，注册表闭环校验） */
+  readonly id: string;
+  /** 声明式顺序（config.yml `gates.order` 可覆盖），小者先执行 */
+  order: number;
+  /** 决策协议：返回三态 GateDecision */
+  evaluate(ctx: GateContext): Promise<GateDecision> | GateDecision;
+}
+
 /**
  * 门禁上下文
  */
@@ -39,6 +80,12 @@ export interface GateContext {
   oldContractPath?: string;
   newContractPath?: string;
   openApiSpec?: string;
+
+  // Command Gate
+  command?: string;
+
+  // Acceptance Gate
+  tasksPath?: string;
   
   // 通用
   timeout?: number;

package/src/hooks/CONTEXT.md

@@ -3,9 +3,16 @@
 ## 职责
 通用 Hook 管线：注册 → 排序 → 错误隔离 → 采样执行。无业务逻辑，consumer 自行定义 hook 名称和语义。
 
+H5（#44）起增加两个机制（G2/G7）：
+- **注册表闭环**：`assertHookRegistryClosed(configs, hooks)` 声明（HookConfig）↔ 实现（HookDefinition）双向校验——引用未注册/注册无定义/重复均抛错，复制 checker 闭环模式；断言限构建/测试期，不进运行时热路径
+- **配置归一**：`HookConfig { name, enabled, errorStrategy }` 为 per-hook 配置唯一真相；`toErrorStrategy(blocking)` 承载 studio `blocking` → errorStrategy 的无损映射
+
 ## 核心导出
-- `HookRegistry` — Hook 注册表
-- `HookPipeline` — Hook 执行管线(注册/排序/错误隔离/采样)
+- `HookRegistry` — Hook 注册表（register/get/getEnabled/setEnabled/clear/listAll）
+- `HookPipeline` — Hook 执行管线（注册/排序/错误隔离/采样；errorStrategy block/warn/ignore）
+- `assertHookRegistryClosed` — 注册表闭环双向校验（构建/测试期）
+- `HookConfig`（type）— per-hook 配置声明（归一后形状）
+- `toErrorStrategy` — blocking → errorStrategy 无损映射（G7）
 - `bootstrapHarness` / `bootstrapHarnessSync` — Harness 启动引导
 
 ## 依赖关系
@@ -16,8 +23,11 @@
 ## 约定
 - 无业务逻辑，只提供管线能力
 - Consumer 自行定义 hook 名称和触发时机
+- **闭环**：声明配置与注册实现必须一一对应，缺一抛错（消灭「hook 定义不注册 = 死代码」类人记规矩）
+- **映射语义**：blocking=true → 'block'（失败阻断管线，停止后续 hook、passed=false）；blocking=false → 'warn'（记录警告继续）；未声明 strategy 静默跳过（历史行为保留）
 - 错误隔离：单个 hook 失败不影响其他 hook
 
 ## 注意事项
 - 通用管线设计，不绑定特定生命周期
 - 采样执行用于高频 hook(减少性能影响)
+- 闭环断言是纯函数，由 consumer 在其注册点/测试中调用；harness 无内置 hook 定义，不自动断言

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

@@ -124,7 +124,6 @@ describe('bootstrapHarnessSync', () => {
     // Check that mergedConstraints has the expected structure
     expect(result.mergedConstraints).toHaveProperty('ironLaws');
     expect(result.mergedConstraints).toHaveProperty('guidelines');
-    expect(result.mergedConstraints).toHaveProperty('tips');
   });
 
   it('registers hook definitions when provided', () => {

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

@@ -0,0 +1,19 @@
+/**
+ * Hook 配置归一映射语义测试（G7）
+ *
+ * blocking → errorStrategy 无损映射：
+ * - blocking=true → 'block'（失败阻断管线）
+ * - blocking=false → 'warn'（记录警告继续）
+ */
+
+import { toErrorStrategy } from '../config';
+
+describe('toErrorStrategy（blocking → errorStrategy 无损映射，G7）', () => {
+  it('blocking=true → block（失败阻断管线）', () => {
+    expect(toErrorStrategy(true)).toBe('block');
+  });
+
+  it('blocking=false → warn（记录警告继续）', () => {
+    expect(toErrorStrategy(false)).toBe('warn');
+  });
+});

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

@@ -0,0 +1,79 @@
+/**
+ * HookPipeline errorStrategy 语义测试（G7 映射语义确认）
+ *
+ * block/warn 行为是 studio safeCallHook 语义在管线侧的无损承载面：
+ * - 'block'：hook 失败 → passed=false、blockedBy 记名、停止执行后续 hook
+ * - 'warn'：hook 失败 → 记录警告、继续执行后续 hook、passed 不受影响
+ * - 'ignore'/未声明：静默跳过（历史行为保留）
+ */
+
+import { HookPipeline } from '../pipeline';
+import { HookRegistry } from '../registry';
+import type { HookDefinition } from '../types';
+
+function makeRegistry(hooks: HookDefinition[]): { registry: HookRegistry; pipeline: HookPipeline } {
+  const registry = new HookRegistry();
+  registry.registerAll(hooks);
+  return { registry, pipeline: new HookPipeline(registry) };
+}
+
+describe('HookPipeline errorStrategy 语义', () => {
+  it('block：失败阻断管线（passed=false、blockedBy 记名、停止后续 hook）', async () => {
+    const second = jest.fn().mockResolvedValue({ passed: true });
+    const { pipeline } = makeRegistry([
+      { name: 'first', phase: 'before', errorStrategy: 'block', execute: async () => ({ passed: false, error: 'boom' }) },
+      { name: 'second', phase: 'before', execute: second },
+    ]);
+
+    const result = await pipeline.run('before', {});
+
+    expect(result.passed).toBe(false);
+    expect(result.blockedBy).toEqual(['first']);
+    expect(second).not.toHaveBeenCalled();
+  });
+
+  it('warn：失败记录警告并继续（passed 不受影响、后续 hook 照常执行）', async () => {
+    const second = jest.fn().mockResolvedValue({ passed: true });
+    const { pipeline } = makeRegistry([
+      { name: 'first', phase: 'before', errorStrategy: 'warn', execute: async () => ({ passed: false, error: 'soft' }) },
+      { name: 'second', phase: 'before', execute: second },
+    ]);
+
+    const result = await pipeline.run('before', {});
+
+    expect(result.passed).toBe(true);
+    expect(result.warnings).toEqual(['first']);
+    expect(result.blockedBy).toEqual([]);
+    expect(second).toHaveBeenCalled();
+  });
+
+  it('block 失败停在当前 phase，不改变其它 phase 的 hook', async () => {
+    const afterHook = jest.fn().mockResolvedValue({ passed: true });
+    const { pipeline } = makeRegistry([
+      { name: 'blocker', phase: 'before', errorStrategy: 'block', execute: async () => ({ passed: false }) },
+      { name: 'afterHook', phase: 'after', execute: afterHook },
+    ]);
+
+    const before = await pipeline.run('before', {});
+    expect(before.passed).toBe(false);
+
+    const after = await pipeline.run('after', {});
+    expect(after.passed).toBe(true);
+    expect(afterHook).toHaveBeenCalled();
+  });
+
+  it('未声明 errorStrategy：静默跳过（历史行为保留）', async () => {
+    const second = jest.fn().mockResolvedValue({ passed: true });
+    const { pipeline } = makeRegistry([
+      { name: 'first', phase: 'before', execute: async () => ({ passed: false }) },
+      { name: 'second', phase: 'before', execute: second },
+    ]);
+
+    const result = await pipeline.run('before', {});
+
+    expect(result.passed).toBe(true);
+    expect(result.blockedBy).toEqual([]);
+    expect(result.warnings).toEqual([]);
+    expect(second).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,67 @@
+/**
+ * Hook 注册表闭环双向校验测试（H5，复制 checker 闭环模式）
+ *
+ * 两个失败方向 + 重复声明/注册都必须抛错；闭环通过时不抛错。
+ */
+
+import { assertHookRegistryClosed, HookRegistry } from '../registry';
+import type { HookConfig, HookDefinition } from '../types';
+
+function makeHook(name: string): HookDefinition {
+  return {
+    name,
+    phase: 'before',
+    execute: async () => ({ passed: true }),
+  };
+}
+
+function makeConfig(name: string): HookConfig {
+  return { name, enabled: true, errorStrategy: 'block' };
+}
+
+describe('assertHookRegistryClosed', () => {
+  it('声明与注册一一对应时通过', () => {
+    const configs = [makeConfig('beforeAgentExecute'), makeConfig('afterReview')];
+    const hooks = [makeHook('beforeAgentExecute'), makeHook('afterReview')];
+    expect(() => assertHookRegistryClosed(configs, hooks)).not.toThrow();
+  });
+
+  it('空声明 + 空注册通过（无 hook 的 consumer 合法）', () => {
+    expect(() => assertHookRegistryClosed([], [])).not.toThrow();
+  });
+
+  it('引用未注册 → 抛错：声明了配置但没有注册实现', () => {
+    const configs = [makeConfig('beforeAgentExecute'), makeConfig('ghostHook')];
+    const hooks = [makeHook('beforeAgentExecute')];
+    expect(() => assertHookRegistryClosed(configs, hooks)).toThrow(
+      /hook 配置 "ghostHook" 引用的实现未注册/
+    );
+  });
+
+  it('注册无定义 → 抛错：注册了实现但没有配置声明', () => {
+    const configs = [makeConfig('beforeAgentExecute')];
+    const hooks = [makeHook('beforeAgentExecute'), makeHook('orphanHook')];
+    expect(() => assertHookRegistryClosed(configs, hooks)).toThrow(
+      /hook "orphanHook" 注册了实现但没有对应配置声明/
+    );
+  });
+
+  it('重复声明 → 抛错', () => {
+    const configs = [makeConfig('dup'), makeConfig('dup')];
+    const hooks = [makeHook('dup')];
+    expect(() => assertHookRegistryClosed(configs, hooks)).toThrow(/重复声明/);
+  });
+
+  it('重复注册 → 抛错', () => {
+    const configs = [makeConfig('dup')];
+    const hooks = [makeHook('dup'), makeHook('dup')];
+    expect(() => assertHookRegistryClosed(configs, hooks)).toThrow(/重复注册/);
+  });
+
+  it('与 HookRegistry.listAll 组合可用（consumer 注册点用法）', () => {
+    const registry = new HookRegistry();
+    registry.registerAll([makeHook('beforeAgentExecute')]);
+    expect(() => assertHookRegistryClosed([makeConfig('beforeAgentExecute')], registry.listAll()))
+      .not.toThrow();
+  });
+});

package/src/hooks/bootstrap.ts

@@ -74,7 +74,6 @@ export async function bootstrapHarness(
 
   // 2. 初始化核心组件
   const checker = ConstraintChecker.getInstance();
-  checker.setCustomConfig(mergedConstraints);
   checker.setTraceRecorder(getTraceCollector());
 
   const sessions = new SessionManager(resolvedPath);
@@ -112,7 +111,6 @@ export function bootstrapHarnessSync(
   const mergedConstraints = loader.mergeConstraints();
 
   const checker = ConstraintChecker.getInstance();
-  checker.setCustomConfig(mergedConstraints);
   checker.setTraceRecorder(getTraceCollector());
 
   const sessions = new SessionManager(resolvedPath);

package/src/hooks/config.ts

@@ -0,0 +1,29 @@
+/**
+ * Hook 配置归一（G7）
+ *
+ * studio 侧 per-hook 运行时配置（`blocking: boolean`）与 harness 侧
+ * `HookDefinition.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 继续
+ *
+ * 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 function toErrorStrategy(blocking: boolean): Extract<HookErrorStrategy, 'block' | 'warn'> {
+  return blocking ? 'block' : 'warn';
+}

package/src/hooks/index.ts

@@ -6,8 +6,9 @@
  */
 
 export * from './types';
-export { HookRegistry } from './registry';
+export { HookRegistry, assertHookRegistryClosed } from './registry';
 export { HookPipeline } from './pipeline';
+export { toErrorStrategy } from './config';
 export {
   bootstrapHarness,
   bootstrapHarnessSync,

package/src/hooks/registry.ts

@@ -4,7 +4,66 @@
  * 纯簿记，无执行逻辑。线程不安全（Node.js 单线程）。
  */
 
-import type { HookDefinition, HookPhase } from './types';
+import type { HookConfig, HookDefinition, HookPhase } from './types';
+
+/**
+ * 注册表闭环双向校验（H5，复制 checker 闭环模式）
+ *
+ * 声明（HookConfig，consumer 的 per-hook 配置表）↔ 实现（注册的
+ * HookDefinition）加载期双向校验，任一不满足即抛错，拒绝静默缺失：
+ * - 引用未注册 → 抛错（声明了配置但没有注册实现 = 死配置）
+ * - 注册无定义 → 抛错（注册了实现但没有配置声明 = 死代码）
+ * - 重复声明 / 重复注册 → 抛错
+ *
+ * 断言限构建/测试期调用（harness 无内置 hook 定义，加载期闭环由
+ * consumer 在其注册点/测试中调用本函数），不进入运行时热路径，
+ * 不破坏 --help/--version 懒加载。消灭「hook 定义不注册 = 死代码」
+ * 类 prompt 规矩（studio 侧随动）。
+ *
+ * @throws 任一方向不满足时抛错
+ */
+export function assertHookRegistryClosed<C = unknown, R = unknown>(
+  configs: readonly HookConfig[],
+  hooks: readonly HookDefinition<C, R>[]
+): void {
+  const configNames = new Set<string>();
+  for (const config of configs) {
+    if (configNames.has(config.name)) {
+      throw new Error(
+        `[harness] hook 注册表闭环校验失败：hook 配置 "${config.name}" 重复声明。`
+      );
+    }
+    configNames.add(config.name);
+  }
+
+  const hookNames = new Set<string>();
+  for (const hook of hooks) {
+    if (hookNames.has(hook.name)) {
+      throw new Error(
+        `[harness] hook 注册表闭环校验失败：hook "${hook.name}" 重复注册。`
+      );
+    }
+    hookNames.add(hook.name);
+  }
+
+  for (const config of configs) {
+    if (!hookNames.has(config.name)) {
+      throw new Error(
+        `[harness] hook 注册表闭环校验失败：hook 配置 "${config.name}" 引用的实现未注册。` +
+        `请注册同名 HookDefinition，或删除该配置声明。`
+      );
+    }
+  }
+
+  for (const hook of hooks) {
+    if (!configNames.has(hook.name)) {
+      throw new Error(
+        `[harness] hook 注册表闭环校验失败：hook "${hook.name}" 注册了实现但没有对应配置声明。` +
+        `请补齐 HookConfig 声明，或移除该实现。`
+      );
+    }
+  }
+}
 
 export class HookRegistry<C = unknown, R = unknown> {
   private hooks: Map<string, HookDefinition<C, R>> = new Map();

package/src/hooks/types.ts

@@ -15,6 +15,27 @@ export type HookPhase = 'before' | 'after' | 'around';
  */
 export type HookErrorStrategy = 'block' | 'warn' | 'ignore';
 
+/**
+ * Hook 配置（G7 归一后形状：consumer 侧的 per-hook 声明表）
+ *
+ * 声明与实现构成注册表闭环（assertHookRegistryClosed 双向校验）：
+ * - 声明（HookConfig）是「定义」侧：引用未注册实现 → 抛错
+ * - 注册（HookDefinition）是「实现」侧：注册无对应声明 → 抛错
+ *
+ * 对应 studio 侧 per-hook 运行时配置（hooks/config.ts 的 DEFAULTS）语义：
+ * blocking:true ↔ errorStrategy 'block'（失败阻断管线），
+ * blocking:false ↔ errorStrategy 'warn'（记录警告继续）——无损映射见
+ * config.ts 的 toErrorStrategy。
+ */
+export interface HookConfig {
+  /** Hook 唯一名称（须与注册的 HookDefinition.name 一致） */
+  name: string;
+  /** 是否启用（false 时不进入管线） */
+  enabled: boolean;
+  /** 错误策略：block=失败阻断管线，warn=记录警告继续 */
+  errorStrategy: 'block' | 'warn';
+}
+
 /**
  * Hook 定义
  *

package/src/index.ts

@@ -3,10 +3,9 @@
  * 
  * 通用工程约束框架
  * 
- * 三层约束体系：
- * - Iron Laws：绝对禁止，无例外
- * - Guidelines：优先建议，有例外
- * - Tips：信息性提示，可忽略
+ * 约束体系（ADR-0001 kind 二元）：
+ * - check：可执行检查（Iron Laws 阻断 / Guidelines 告警）
+ * - prompt：纯文本注入，不参与检查
  * 
  * 门禁系统：
  * - PassesGate：测试门控
@@ -42,12 +41,6 @@ export * from './monitoring';
 // ========================================
 export * from './failure';
 
-// ========================================
-// 架构约束导出
-// ========================================
-export * from './architecture/constraint-engine';
-export * from './architecture/cross-project-checker';
-
 // ========================================
 // Spec 检查导出
 // ========================================
@@ -79,16 +72,7 @@ export * from './verification';
 export * from './dashboard';
 
 // ========================================
-// LLM 适配器导出
-// ========================================
-export * from './llm';
-
-// ========================================
-// 治理模块导出
-// ========================================
-
-// ========================================
-// 工具注册表导出
+// 工具路径导出
 // ========================================
 export * from './tools';
 
@@ -171,7 +155,7 @@ export function registerExecutor(
 }
 
 /**
- * 检查约束（三层）
+ * 检查约束（check 层）
  *
  * @param context - 约束上下文
  * @param options.onTrace - 每条约束检查后的回调（用于记录 trace 到外部存储）
@@ -184,7 +168,6 @@ export async function checkConstraints(
   if (options?.onTrace) {
     for (const r of result.ironLaws) options.onTrace(r);
     for (const r of result.guidelines) options.onTrace(r);
-    for (const r of result.tips) options.onTrace(r);
   }
   return result;
 }

package/src/knowledge/import.ts

@@ -13,7 +13,7 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import type { KnowledgeEntry, KnowledgeType, StorageLayer } from './types';
+import type { KnowledgeEntry, KnowledgeSubsystem, StorageLayer } from './types';
 import type { KnowledgeStore } from './store';
 
 // ── 导入源 ───────────────────────────────────────────────
@@ -62,7 +62,7 @@ export interface ImportConfig {
   manualEntries?: Array<{
     title: string;
     content: string;
-    type: KnowledgeType;
+    type: KnowledgeSubsystem;
     tags?: string[];
   }>;
   /** 是否跳过已导入的 */
@@ -366,7 +366,7 @@ export class ColdStartImporter {
   private createEntry(params: {
     title: string;
     content: string;
-    type: KnowledgeType;
+    type: KnowledgeSubsystem;
     tags: string[];
     layer: StorageLayer;
   }): KnowledgeEntry {

package/src/knowledge/ingest.ts

@@ -7,7 +7,7 @@
 
 import type {
   KnowledgeEntry,
-  KnowledgeType,
+  KnowledgeSubsystem,
   IngestOptions,
   SourceRef,
 } from './types';
@@ -176,19 +176,19 @@ export class KnowledgeIngest {
     };
   }
 
-  private generateId(type: KnowledgeType): string {
+  private generateId(type: KnowledgeSubsystem): string {
     const prefix = type.toUpperCase().slice(0, 3);
     const existing = this.store.list({ types: [type] });
     const seq = String(existing.length + 1).padStart(3, '0');
     return `${prefix}-${seq}`;
   }
 
-  private inferType(_options: IngestOptions): KnowledgeType {
+  private inferType(_options: IngestOptions): KnowledgeSubsystem {
     // Default to 'guideline' if type can't be inferred
     return 'guideline';
   }
 
-  private findDuplicate(title: string, content: string, type: KnowledgeType): KnowledgeEntry | undefined {
+  private findDuplicate(title: string, content: string, type: KnowledgeSubsystem): KnowledgeEntry | undefined {
     // A1: Read from disk directly to avoid stale index causing dedup failure
     const all = this.store.readEntriesFromDisk().filter(e => e.type === type);
 

package/src/knowledge/lifecycle-hooks.ts

@@ -6,7 +6,7 @@
  * - 完成时提取新知识
  */
 
-import type { KnowledgeEntry, KnowledgeType } from './types';
+import type { KnowledgeEntry, KnowledgeSubsystem } from './types';
 import type { KnowledgeStore } from './store';
 import { KnowledgeQuery } from './query';
 import type { ContextSource } from '../context/types';
@@ -48,7 +48,7 @@ export class KnowledgeLifecycleHooks {
   onSessionStart(options?: {
     phase?: string;
     budget?: number;
-    focusTypes?: KnowledgeType[];
+    focusTypes?: KnowledgeSubsystem[];
     exclude?: string[];
   }): ContextSource[] {
     const budget = options?.budget ?? this.config.injectionBudget ?? 800;
@@ -173,7 +173,7 @@ export class KnowledgeLifecycleHooks {
   private createExtractionEntry(params: {
     title: string;
     content: string;
-    type: KnowledgeType;
+    type: KnowledgeSubsystem;
     tags: string[];
   }): KnowledgeEntry {
     return {

package/src/knowledge/types.ts

@@ -3,7 +3,7 @@
  *
  * Three orthogonal dimensions:
  * - StorageLayer: where knowledge lives (shared boundary)
- * - KnowledgeType: what knowledge describes (MECE)
+ * - KnowledgeSubsystem: what knowledge describes (MECE)
  * - MaturityLevel: how trusted (lifecycle)
  */
 
@@ -11,9 +11,6 @@
 
 export type KnowledgeSubsystem = 'model' | 'decision' | 'guideline' | 'pitfall' | 'process' | 'architecture';
 
-/** @deprecated Use KnowledgeSubsystem */
-export type KnowledgeType = KnowledgeSubsystem;
-
 export type MaturityLevel = 'draft' | 'verified' | 'proven' | 'archived' | 'active' | 'deprecated';
 
 export type StorageLayer = 'personal' | 'team' | 'tech' | 'domain' | 'project' | 'system';
@@ -28,7 +25,7 @@ export type KnowledgeOrigin = 'human' | 'agent' | 'external' | 'system';
 
 export interface KnowledgeEntry {
   id: string;
-  type: KnowledgeType;
+  type: KnowledgeSubsystem;
   title: string;
   content: string;
   maturity: MaturityLevel;
@@ -81,7 +78,7 @@ export interface QueryBudget {
   phase: string;
   maxTokens: number;
   maxEntries: number;
-  focusTypes: KnowledgeType[];
+  focusTypes: KnowledgeSubsystem[];
 }
 
 export interface QueryResult {
@@ -92,7 +89,7 @@ export interface QueryResult {
 }
 
 export interface QueryFilter {
-  types?: KnowledgeType[];
+  types?: KnowledgeSubsystem[];
   maturity?: MaturityLevel[];
   layers?: StorageLayer[];
   tags?: string[];
@@ -180,7 +177,7 @@ export interface ReferenceRecord {
 
 export interface IndexEntry {
   id: string;
-  type: KnowledgeType;
+  type: KnowledgeSubsystem;
   title: string;
   maturity: MaturityLevel;
   layer: StorageLayer;