openhermes 4.11.2 → 4.12.1

package/harness/lib/hooks/builtins/error-recovery-hook.ts

@@ -28,13 +28,13 @@ export const errorRecoveryHook: PostToolUseHook = {
 
     // Classify the error and get a recovery action
     const handler = RecoveryHandler.getInstance();
-    const errorContext: ErrorContext = {
-      sessionId: context.sessionId,
-      error: new Error(output.slice(0, 500)), // Truncate for classification
-      attempt: (context._recoveryAttempt as number) ?? 0,
-      timestamp: Date.now(),
-      agent: context.agent,
-    };
+    const errorContext: ErrorContext = {
+      sessionId: context.sessionId,
+      error: new Error(output.slice(0, 500)), // Truncate for classification
+      attempt: context._recoveryAttempt ?? 0,
+      timestamp: Date.now(),
+      agent: context.agent,
+    };
 
     const action = handler.handleError(errorContext);
 

package/harness/lib/hooks/builtins/memory-sync-hook.ts

@@ -9,7 +9,7 @@ import { HookPhase, HookResult } from "../types.ts";
 import type { HookContext, PostToolUseHook } from "../types.ts";
 import { MemoryManager } from "../../memory/memory-manager.ts";
 import { PlanStore } from "../../memory/plan-store.ts";
-import { findLatestPlanFile } from "../../../../bootstrap.ts";
+import { resolvePlanAccess } from "../../plans/plan-location.ts";
 import { MemoryLevel } from "../../memory/interfaces.ts";
 
 export const memorySyncHook: PostToolUseHook = {
@@ -23,7 +23,7 @@ export const memorySyncHook: PostToolUseHook = {
 
   async execute(context: HookContext, output: string) {
     // Sync memory entries to plan file
-    const planFile = findLatestPlanFile(context.directory);
+    const planFile = resolvePlanAccess(context.directory)?.path ?? null;
     if (!planFile) {
       // No plan file to sync to — skip silently
       return { result: HookResult.CONTINUE };

package/harness/lib/hooks/builtins/next-route-hook.ts

@@ -0,0 +1,24 @@
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, RouteHook } from "../types.ts";
+
+export const nextRouteHook: RouteHook = {
+  metadata: {
+    name: "next-route",
+    priority: 90,
+    phase: HookPhase.EARLY,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext, route: string) {
+    const nextRoute = context._nextRoute?.selected;
+    if (!nextRoute || nextRoute === route) {
+      return { result: HookResult.CONTINUE, modifiedRoute: route };
+    }
+
+    return {
+      result: HookResult.CONTINUE,
+      modifiedRoute: nextRoute,
+    };
+  },
+};

package/harness/lib/hooks/builtins/plan-check-hook.ts

@@ -5,9 +5,9 @@
 // If missing, inject "create plan first" instruction.
 // ---------------------------------------------------------------------------
 
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, PreToolUseHook } from "../types.ts";
-import { findLatestPlanFile } from "../../../../bootstrap.ts";
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PreToolUseHook } from "../types.ts";
+import { resolvePlanAccess } from "../../plans/plan-location.ts";
 
 export const planCheckHook: PreToolUseHook = {
   metadata: {
@@ -18,8 +18,8 @@ export const planCheckHook: PreToolUseHook = {
     errorHandling: "propagate",
   },
 
-  async execute(context: HookContext) {
-    const planFile = findLatestPlanFile(context.directory);
+  async execute(context: HookContext) {
+    const planFile = resolvePlanAccess(context.directory)?.path ?? null;
 
     if (!planFile) {
       return {

package/harness/lib/hooks/builtins/route-tracking-hook.ts

@@ -2,12 +2,17 @@
 // RouteTrackingHook — RouteHook, priority=55, phase=LATE
 //
 // Loop guard — mechanically enforce two limits:
-// 1. Same skill visited 5+ times in one chain
-// 2. 8+ consecutive unproductive hops
+// 1. Same skill visited N+ times in one chain (default 5)
+// 2. N+ consecutive unproductive hops (default 8)
+//
+// Config from _guardConfig (centralized) with fallback to _routeTrackingConfig
+// for backward compatibility. Progressive warning at thresholds before hard stop.
 // ---------------------------------------------------------------------------
 
 import { HookPhase, HookResult } from "../types.ts";
 import type { HookContext, RouteHook } from "../types.ts";
+import type { GuardConfig, GuardProgression } from "../../guards/guard-config.ts";
+import { checkGuardProgression, DEFAULT_GUARD_CONFIG } from "../../guards/guard-config.ts";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -55,6 +60,53 @@ export function getHopHistory(sessionId: string): HopRecord[] {
 
 const defaultArtifactCheck: (route: string) => boolean = () => false;
 
+// ---------------------------------------------------------------------------
+// Resolve max values from guard config with fallbacks
+// ---------------------------------------------------------------------------
+
+function resolveMaxValues(context: HookContext): {
+  maxSkillRepeats: number;
+  maxUnproductiveHops: number;
+  artifactCheck: (route: string) => boolean | Promise<boolean>;
+} {
+  // Primary: _guardConfig (centralized)
+  const gc: GuardConfig = context._guardConfig ?? DEFAULT_GUARD_CONFIG;
+  const maxSkillRepeats = gc.maxSkillRepeats;
+  const maxUnproductiveHops = gc.maxUnproductiveHops;
+
+  // Backward compat: _routeTrackingConfig overrides if present
+  const legacy = context._routeTrackingConfig as Partial<RouteTrackingConfig> | undefined;
+  const artifactCheck = legacy?.artifactCheck ?? defaultArtifactCheck;
+  const legacySkillRepeats = legacy?.maxSkillRepeats;
+  const legacyUnproductiveHops = legacy?.maxUnproductiveHops;
+
+  return {
+    maxSkillRepeats: legacySkillRepeats ?? maxSkillRepeats,
+    maxUnproductiveHops: legacyUnproductiveHops ?? maxUnproductiveHops,
+    artifactCheck,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Build optiRoute report helper
+// ---------------------------------------------------------------------------
+
+function buildOptiRouteReport(
+  state: RouteTrackingState,
+  reason: string,
+  maxSkillRepeats: number,
+  maxUnproductiveHops: number,
+) {
+  return {
+    reason,
+    chain: [...state.hops],
+    skillCounts: Object.fromEntries(state.skillCounts),
+    unproductiveCount: state.unproductiveCount,
+    maxSkillRepeats,
+    maxUnproductiveHops,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Hook
 // ---------------------------------------------------------------------------
@@ -88,13 +140,9 @@ export const routeTrackingHook: RouteHook = {
       sessionStates.set(sessionId, state);
     }
 
-    // Read config from context (or use defaults)
-    // Support both `_routeTrackingConfig` and `hooks.route_tracking.*` conventions
-    const config =
-      (context._routeTrackingConfig ?? {}) as RouteTrackingConfig;
-    const maxSkillRepeats = config.maxSkillRepeats ?? 5;
-    const maxUnproductiveHops = config.maxUnproductiveHops ?? 8;
-    const artifactCheck = config.artifactCheck ?? defaultArtifactCheck;
+    // Resolve config values
+    const { maxSkillRepeats, maxUnproductiveHops, artifactCheck } = resolveMaxValues(context);
+    const gc: GuardConfig = context._guardConfig ?? DEFAULT_GUARD_CONFIG;
 
     // Record the hop
     const producedArtifact = await artifactCheck(route);
@@ -116,32 +164,38 @@ export const routeTrackingHook: RouteHook = {
       state.unproductiveCount += 1;
     }
 
-    // Check 1: Same skill repeated too many times
-    if (currentSkillCount >= maxSkillRepeats) {
-      context._optiRoute = {
-        reason: `Same skill "${route}" visited ${currentSkillCount} times (max ${maxSkillRepeats})`,
-        chain: [...state.hops],
-        skillCounts: Object.fromEntries(state.skillCounts),
-        unproductiveCount: state.unproductiveCount,
+    // Check 1: Same skill repeated too many times — with progressive warning
+    let progression = checkGuardProgression(currentSkillCount, maxSkillRepeats, gc);
+    if (progression.level === "warn" || progression.level === "escalate") {
+      // Progressive warning — annotate context but don't stop
+      context._guardProgression = progression;
+    }
+    if (progression.level === "stop") {
+      context._optiRoute = buildOptiRouteReport(
+        state,
+        `Same skill "${route}" visited ${currentSkillCount} times (max ${maxSkillRepeats})`,
         maxSkillRepeats,
         maxUnproductiveHops,
-      };
+      );
       return { result: HookResult.STOP };
     }
 
-    // Check 2: Too many consecutive unproductive hops
-    if (state.unproductiveCount >= maxUnproductiveHops) {
-      context._optiRoute = {
-        reason: `${state.unproductiveCount} consecutive unproductive hops (max ${maxUnproductiveHops})`,
-        chain: [...state.hops],
-        skillCounts: Object.fromEntries(state.skillCounts),
-        unproductiveCount: state.unproductiveCount,
+    // Check 2: Too many consecutive unproductive hops — with progressive warning
+    progression = checkGuardProgression(state.unproductiveCount, maxUnproductiveHops, gc);
+    if (progression.level === "warn" || progression.level === "escalate") {
+      // Progressive warning — annotate context but don't stop
+      context._guardProgression = progression;
+    }
+    if (progression.level === "stop") {
+      context._optiRoute = buildOptiRouteReport(
+        state,
+        `${state.unproductiveCount} consecutive unproductive hops (max ${maxUnproductiveHops})`,
         maxSkillRepeats,
         maxUnproductiveHops,
-      };
+      );
       return { result: HookResult.STOP };
     }
 
     return { result: HookResult.CONTINUE, modifiedRoute: route };
   },
-};
+};

package/harness/lib/hooks/builtins/subagent-failure-hook.ts

@@ -0,0 +1,93 @@
+// ---------------------------------------------------------------------------
+// SubagentFailureHook — PostToolUse, priority=45, phase=LATE
+//
+// Mechanically tracks subagent task failures.
+// At maxSubagentFailures consecutive failures on the same task,
+// surfaces a BLOCKER.
+// ---------------------------------------------------------------------------
+
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PostToolUseHook } from "../types.ts";
+import { DEFAULT_GUARD_CONFIG, checkGuardProgression } from "../../guards/guard-config.ts";
+import type { GuardConfig } from "../../guards/guard-config.ts";
+
+/** Module-level failure tracker — maps sessionId to consecutive failure count */
+const failureCounters = new Map<string, number>();
+
+export function resetSubagentFailures(sessionId?: string): void {
+  if (sessionId) {
+    failureCounters.delete(sessionId);
+  } else {
+    failureCounters.clear();
+  }
+}
+
+export function getSubagentFailureCount(sessionId: string): number {
+  return failureCounters.get(sessionId) ?? 0;
+}
+
+// Error pattern detection — reuses the same patterns from error-recovery-hook
+function outputLooksLikeFailure(output: string): boolean {
+  if (!output || output.length === 0) return true; // Empty output = failure
+  const errorPatterns = [
+    /error/i, /exception/i, /failed/i, /failure/i,
+    /unable to/i, /could not/i, /not found/i,
+    /ECONNREFUSED/i, /ETIMEDOUT/i, /rate.?limited/i,
+    /too many requests/i, /timeout/i, /execution.?timed.?out/i,
+  ];
+  const head = output.slice(0, 2000);
+  return errorPatterns.some((p) => p.test(head));
+}
+
+export const subagentFailureHook: PostToolUseHook = {
+  metadata: {
+    name: "subagent-failure",
+    priority: 45,
+    phase: HookPhase.LATE,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext, output: string) {
+    const sessionId = context.sessionId;
+    const config: GuardConfig = context._guardConfig ?? DEFAULT_GUARD_CONFIG;
+    const maxFailures = config.maxSubagentFailures;
+
+    if (maxFailures <= 0) {
+      // Disabled
+      return { result: HookResult.CONTINUE };
+    }
+
+    const isFailure = outputLooksLikeFailure(output);
+    let currentCount = failureCounters.get(sessionId) ?? 0;
+
+    if (isFailure) {
+      currentCount += 1;
+      failureCounters.set(sessionId, currentCount);
+    } else {
+      // Success — reset counter
+      failureCounters.set(sessionId, 0);
+      return { result: HookResult.CONTINUE };
+    }
+
+    // Check progression
+    const progression = checkGuardProgression(currentCount, maxFailures, config);
+
+    if (progression.level === "stop") {
+      // Surface BLOCKER
+      return {
+        result: HookResult.INJECT,
+        modifiedOutput: output,
+        injectRecovery: `[HOOK: BLOCKER] ${currentCount} consecutive subagent failures (max ${maxFailures}). Surface to orchestrator with findings and stop delegating.`,
+      };
+    }
+
+    if (progression.level === "warn" || progression.level === "escalate") {
+      // Annotate but don't stop
+      context._guardProgression = progression;
+      context._subagentFailures = currentCount;
+    }
+
+    return { result: HookResult.CONTINUE };
+  },
+};

package/harness/lib/hooks/hooks.test.ts

@@ -4,40 +4,45 @@
 
 import { describe, it, before, after, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import {
-  HookPhase,
-  HookResult,
-  HookRegistry,
-  planCheckHook,
+import {
+  HookPhase,
+  HookResult,
+  HookRegistry,
+  planCheckHook,
   shellDetectHook,
   confidenceGateHook,
   delegationDepthHook,
   resetDepthTracker,
   errorRecoveryHook,
   memorySyncHook,
-  routeTrackingHook,
-  resetRouteTracker,
-  getHopHistory,
-  sanityCheckHook,
-} from "./index.ts";
+  routeTrackingHook,
+  resetRouteTracker,
+  getHopHistory,
+  sanityCheckHook,
+  dynamicRouteHook,
+} from "./index.ts";
 import { AnomalyTracker } from "../sanity/anomaly-tracker.ts";
-import type {
-  HookContext,
-  HookMetadata,
-  PreToolUseHook,
-  PostToolUseHook,
-  RouteHook,
+import type {
+  HookContext,
+  HookContextPatch,
+  HookMetadata,
+  PreToolUseHook,
+  PostToolUseHook,
+  RouteHook,
   SessionHook,
-} from "./types.ts";
+} from "./types.ts";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeContext(overrides?: Partial<HookContext>): HookContext {
-  return {
-    sessionId: "test-session",
-    agent: "oh-builder",
+function makeContext(overrides?: HookContextPatch): HookContext {
+  return {
+    sessionId: "test-session",
+    agent: "oh-builder",
     directory: "/tmp/test-project",
     sessions: new Map(),
     ...overrides,
@@ -47,13 +52,13 @@ function makeContext(overrides?: Partial<HookContext>): HookContext {
 function makePreToolHook(
   name: string,
   overrides?: Partial<HookMetadata>,
-  impl?: (
-    ctx: HookContext,
-  ) => Promise<{
-    result: HookResult;
-    modifiedContext?: Partial<HookContext>;
-  }>,
-): PreToolUseHook {
+  impl?: (
+    ctx: HookContext,
+  ) => Promise<{
+    result: HookResult;
+    modifiedContext?: HookContextPatch;
+  }>,
+): PreToolUseHook {
   return {
     metadata: {
       name,
@@ -135,10 +140,18 @@ function makeSessionHook(
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("HookRegistry", () => {
-  beforeEach(() => {
-    HookRegistry.resetInstance();
-    resetDepthTracker();
+describe("HookRegistry", () => {
+  const tmpDirs: string[] = [];
+
+  after(() => {
+    for (const dir of tmpDirs) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  beforeEach(() => {
+    HookRegistry.resetInstance();
+    resetDepthTracker();
     resetRouteTracker();
   });
 
@@ -379,10 +392,13 @@ describe("HookRegistry", () => {
         }),
       );
 
-      const result = await reg.executePreTool(makeContext());
-      assert.equal(result.result, HookResult.CONTINUE);
-      assert.equal(result.modifiedContext?._track, "ran");
-    });
+      const result = await reg.executePreTool(makeContext());
+      assert.equal(result.result, HookResult.CONTINUE);
+      assert.equal(result.modifiedContext?.sessionId, "test-session");
+      assert.equal(result.modifiedContext?.agent, "oh-builder");
+      assert.equal(result.modifiedContext?.directory, "/tmp/test-project");
+      assert.equal(result.modifiedContext?._track, "ran");
+    });
 
     it("stops execution on STOP result", async () => {
       const reg = HookRegistry.getInstance();
@@ -427,7 +443,7 @@ describe("HookRegistry", () => {
     });
   });
 
-  describe("executePostTool", () => {
+  describe("executePostTool", () => {
     it("passes through output without modification", async () => {
       const reg = HookRegistry.getInstance();
       reg.registerPostTool(makePostToolHook("pass"));
@@ -462,9 +478,9 @@ describe("HookRegistry", () => {
       assert.equal(result.modifiedOutput, "[[[HELLO]]]");
     });
 
-    it("injects recovery action", async () => {
-      const reg = HookRegistry.getInstance();
-      reg.registerPostTool(
+    it("injects recovery action", async () => {
+      const reg = HookRegistry.getInstance();
+      reg.registerPostTool(
         makePostToolHook("recovery-test", {}, async () => ({
           result: HookResult.INJECT,
           injectRecovery: "retry with backoff",
@@ -474,10 +490,86 @@ describe("HookRegistry", () => {
       const result = await reg.executePostTool(
         makeContext(),
         "output",
-      );
-      assert.equal(result.recovery, "retry with backoff");
-    });
-  });
+      );
+      assert.equal(result.recovery, "retry with backoff");
+    });
+
+    it("appends structured route guidance from output evidence", async () => {
+      const reg = HookRegistry.getInstance();
+      reg.registerPostTool(dynamicRouteHook);
+
+      const skillsDir = fs.mkdtempSync(path.join(os.tmpdir(), "oh-routing-hook-"));
+      tmpDirs.push(skillsDir);
+      const skillDir = path.join(skillsDir, "oh-review");
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: oh-review
+route:
+  pass:
+    - oh-gauntlet
+    - oh-ship
+  fail: oh-builder
+  blocker: surface
+---\n`);
+
+      const result = await reg.executePostTool(
+        makeContext({ agent: "oh-review", _routingSkillsDir: skillsDir }),
+        'Review complete\nROUTE_EVIDENCE: {"outcome":"pass","target":"oh-ship"}',
+      );
+
+      assert.equal(result.result, HookResult.INJECT);
+      assert.ok(result.modifiedOutput?.includes("Review complete"));
+      assert.ok(result.modifiedOutput?.includes("ROUTE_GUIDANCE:"));
+
+      const guidanceLine = result.modifiedOutput
+        ?.split(/\r?\n/)
+        .find((line) => line.startsWith("ROUTE_GUIDANCE:"));
+      assert.ok(guidanceLine);
+      assert.deepEqual(JSON.parse(guidanceLine!.slice("ROUTE_GUIDANCE:".length).trim()), {
+        outcome: "pass",
+        candidates: ["oh-gauntlet", "oh-ship"],
+        selected: "oh-ship",
+        reason: 'Selected "oh-ship" from output evidence.',
+      });
+    });
+
+    it("ignores malformed structured route evidence safely", async () => {
+      const reg = HookRegistry.getInstance();
+      reg.registerPostTool(dynamicRouteHook);
+
+      const skillsDir = fs.mkdtempSync(path.join(os.tmpdir(), "oh-routing-hook-"));
+      tmpDirs.push(skillsDir);
+      const skillDir = path.join(skillsDir, "oh-review");
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: oh-review
+route:
+  pass:
+    - oh-gauntlet
+    - oh-ship
+  fail: oh-builder
+  blocker: surface
+---\n`);
+
+      const output = 'Review complete\nROUTE_EVIDENCE: {"outcome":"pass","verification":"maybe"}';
+      const result = await reg.executePostTool(
+        makeContext({ agent: "oh-review", _routingSkillsDir: skillsDir }),
+        output,
+      );
+
+      assert.equal(result.result, HookResult.CONTINUE);
+      assert.equal(result.modifiedOutput, output);
+    });
+
+    it("leaves output unchanged when no route evidence is present", async () => {
+      const reg = HookRegistry.getInstance();
+      reg.registerPostTool(dynamicRouteHook);
+
+      const result = await reg.executePostTool(makeContext({ agent: "oh-review" }), "plain output");
+      assert.equal(result.result, HookResult.CONTINUE);
+      assert.equal(result.modifiedOutput, "plain output");
+    });
+  });
 
   describe("executeRoute", () => {
     it("passes route unchanged", async () => {
@@ -723,18 +815,10 @@ describe("HookRegistry", () => {
         // 5th — should STOP (>= maxSkillRepeats=5)
         const result = await routeTrackingHook.execute(ctx, "oh-builder");
         assert.equal(result.result, HookResult.STOP);
-        assert.ok(ctx._optiRoute);
-        assert.ok(
-          (ctx._optiRoute as Record<string, unknown>).reason as string,
-        );
-        assert.ok(
-          ((ctx._optiRoute as Record<string, unknown>).reason as string).includes(
-            "oh-builder",
-          ),
-        );
-        assert.ok(
-          ((ctx._optiRoute as Record<string, unknown>).chain as unknown[]).length === 5,
-        );
+        assert.ok(ctx._optiRoute);
+        assert.ok(ctx._optiRoute.reason);
+        assert.ok(ctx._optiRoute.reason.includes("oh-builder"));
+        assert.ok(ctx._optiRoute.chain.length === 5);
       });
 
       it("stops on 8th unproductive hop (default max 8)", async () => {
@@ -756,12 +840,8 @@ describe("HookRegistry", () => {
         // 8th — should STOP
         const result = await routeTrackingHook.execute(ctx, "oh-builder");
         assert.equal(result.result, HookResult.STOP);
-        assert.ok(ctx._optiRoute);
-        assert.ok(
-          ((ctx._optiRoute as Record<string, unknown>).reason as string).includes(
-            "unproductive",
-          ),
-        );
+        assert.ok(ctx._optiRoute);
+        assert.ok(ctx._optiRoute.reason.includes("unproductive"));
       });
 
       it("productive hop resets unproductive counter", async () => {
@@ -874,13 +954,9 @@ describe("HookRegistry", () => {
         // 3rd unproductive should STOP (>=3)
         const result = await routeTrackingHook.execute(ctx, "oh-gauntlet");
         assert.equal(result.result, HookResult.STOP);
-        assert.ok(ctx._optiRoute);
-        assert.ok(
-          ((ctx._optiRoute as Record<string, unknown>).reason as string).includes(
-            "unproductive",
-          ),
-        );
-      });
+        assert.ok(ctx._optiRoute);
+        assert.ok(ctx._optiRoute.reason.includes("unproductive"));
+      });
     });
   });
 

package/harness/lib/hooks/index.ts

@@ -7,7 +7,10 @@ export {
   HookResult,
 } from "./types.ts";
 export type {
+  HookContextBase,
+  HookContextExtras,
   HookContext,
+  HookContextPatch,
   HookMetadata,
   PreToolUseHook,
   PostToolUseHook,
@@ -26,5 +29,14 @@ export { delegationDepthHook, resetDepthTracker } from "./builtins/delegation-de
 export { errorRecoveryHook } from "./builtins/error-recovery-hook.ts";
 export { memorySyncHook } from "./builtins/memory-sync-hook.ts";
 export { sanityCheckHook } from "./builtins/sanity-check-hook.ts";
+export { dynamicRouteHook } from "./builtins/dynamic-route-hook.ts";
+export { nextRouteHook } from "./builtins/next-route-hook.ts";
 export { routeTrackingHook, resetRouteTracker, getHopHistory } from "./builtins/route-tracking-hook.ts";
 export type { HopRecord, RouteTrackingConfig } from "./builtins/route-tracking-hook.ts";
+
+// Guard configuration
+export type { GuardConfig, GuardProgression, GuardLevel } from "../guards/guard-config.ts";
+export { DEFAULT_GUARD_CONFIG, checkGuardProgression, mergeGuardConfig } from "../guards/guard-config.ts";
+
+// Subagent failure hook
+export { subagentFailureHook, resetSubagentFailures, getSubagentFailureCount } from "./builtins/subagent-failure-hook.ts";

package/harness/lib/hooks/registry.ts

@@ -18,7 +18,7 @@ import { HookPhase, HookResult } from "./types.ts";
 // ---------------------------------------------------------------------------
 
 export class HookRegistry {
-  private static instance: HookRegistry;
+  private static instance: HookRegistry | null = null;
 
   private preToolHooks: PreToolUseHook[] = [];
   private postToolHooks: PostToolUseHook[] = [];
@@ -37,7 +37,7 @@ export class HookRegistry {
 
   /** Reset singleton — used in tests for isolation. */
   static resetInstance(): void {
-    HookRegistry.instance = null as unknown as HookRegistry;
+    HookRegistry.instance = null;
   }
 
   // -----------------------------------------------------------------------
@@ -139,7 +139,7 @@ export class HookRegistry {
    */
   async executePreTool(
     context: HookContext,
-  ): Promise<{ result: HookResult; modifiedContext?: Partial<HookContext> }> {
+  ): Promise<{ result: HookResult; modifiedContext?: HookContext }> {
     const sorted = this.topologicalSort(this.preToolHooks);
     let currentContext = context;
     let hasInjection = false;