openhermes 4.11.2 → 4.13.0

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

@@ -13,28 +13,29 @@ import {
   confidenceGateHook,
   delegationDepthHook,
   resetDepthTracker,
-  errorRecoveryHook,
-  memorySyncHook,
   routeTrackingHook,
   resetRouteTracker,
   getHopHistory,
-  sanityCheckHook,
+  dynamicRouteHook,
 } from "./index.ts";
-import { AnomalyTracker } from "../sanity/anomaly-tracker.ts";
 import type {
   HookContext,
+  HookContextPatch,
   HookMetadata,
   PreToolUseHook,
   PostToolUseHook,
   RouteHook,
   SessionHook,
 } 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 {
+function makeContext(overrides?: HookContextPatch): HookContext {
   return {
     sessionId: "test-session",
     agent: "oh-builder",
@@ -51,7 +52,7 @@ function makePreToolHook(
     ctx: HookContext,
   ) => Promise<{
     result: HookResult;
-    modifiedContext?: Partial<HookContext>;
+    modifiedContext?: HookContextPatch;
   }>,
 ): PreToolUseHook {
   return {
@@ -76,7 +77,6 @@ function makePostToolHook(
   ) => Promise<{
     result: HookResult;
     modifiedOutput?: string;
-    injectRecovery?: string;
   }>,
 ): PostToolUseHook {
   return {
@@ -136,6 +136,14 @@ function makeSessionHook(
 // ---------------------------------------------------------------------------
 
 describe("HookRegistry", () => {
+  const tmpDirs: string[] = [];
+
+  after(() => {
+    for (const dir of tmpDirs) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
   beforeEach(() => {
     HookRegistry.resetInstance();
     resetDepthTracker();
@@ -251,7 +259,7 @@ describe("HookRegistry", () => {
       assert.equal(sorted[2].metadata.name, "late-hook");
     });
 
-    it("handles simple linear dependencies", () => {
+    it("sorts by priority within same phase, ignoring dependencies", () => {
       const reg = HookRegistry.getInstance();
       const a = makePreToolHook("a", {
         phase: HookPhase.EARLY,
@@ -260,89 +268,27 @@ describe("HookRegistry", () => {
       });
       const b = makePreToolHook("b", {
         phase: HookPhase.EARLY,
-        priority: 50,
+        priority: 70,
         dependencies: ["a"],
       });
-      const c = makePreToolHook("c", {
-        phase: HookPhase.EARLY,
-        priority: 50,
-        dependencies: ["b"],
-      });
-
-      const sorted = reg.topologicalSort([c, a, b]);
-      assert.equal(sorted[0].metadata.name, "a");
-      assert.equal(sorted[1].metadata.name, "b");
-      assert.equal(sorted[2].metadata.name, "c");
-    });
-
-    it("handles diamond dependencies (A→B→D and A→C→D)", () => {
-      const reg = HookRegistry.getInstance();
-      const a = makePreToolHook("a", {
-        phase: HookPhase.EARLY,
-        priority: 50,
-        dependencies: [],
-      });
-      const b = makePreToolHook("b", {
-        phase: HookPhase.EARLY,
-        priority: 50,
-        dependencies: ["a"],
-      });
-      const c = makePreToolHook("c", {
-        phase: HookPhase.EARLY,
-        priority: 50,
-        dependencies: ["a"],
-      });
-      const d = makePreToolHook("d", {
-        phase: HookPhase.EARLY,
-        priority: 50,
-        dependencies: ["b", "c"],
-      });
 
-      const sorted = reg.topologicalSort([d, c, b, a]);
-      // A must come first, D must come last
-      assert.equal(sorted[0].metadata.name, "a");
-      assert.equal(sorted[3].metadata.name, "d");
-      // B and C can be in any order but must be before D and after A
-      const bIdx = sorted.findIndex((h) => h.metadata.name === "b");
-      const cIdx = sorted.findIndex((h) => h.metadata.name === "c");
-      assert.ok(bIdx > 0);
-      assert.ok(cIdx > 0);
-      assert.ok(bIdx < 3);
-      assert.ok(cIdx < 3);
-    });
-
-    it("throws on circular dependency (A→B→C→A)", () => {
-      const reg = HookRegistry.getInstance();
-      const a = makePreToolHook("a", {
-        phase: HookPhase.EARLY,
-        dependencies: ["c"],
-      });
-      const b = makePreToolHook("b", {
-        phase: HookPhase.EARLY,
-        dependencies: ["a"],
-      });
-      const c = makePreToolHook("c", {
-        phase: HookPhase.EARLY,
-        dependencies: ["b"],
-      });
-
-      assert.throws(
-        () => reg.topologicalSort([a, b, c]),
-        /Circular dependency detected/,
-      );
+      // Higher priority first (70 > 50), regardless of dependency declaration
+      const sorted = reg.topologicalSort([a, b]);
+      assert.equal(sorted[0].metadata.name, "b");
+      assert.equal(sorted[1].metadata.name, "a");
     });
 
-    it("self-dependency throws", () => {
+    it("preserves original order for equal phase and priority", () => {
       const reg = HookRegistry.getInstance();
-      const a = makePreToolHook("a", {
-        phase: HookPhase.EARLY,
-        dependencies: ["a"],
-      });
+      const c = makePreToolHook("c", { phase: HookPhase.EARLY, priority: 50 });
+      const a = makePreToolHook("a", { phase: HookPhase.EARLY, priority: 50 });
+      const b = makePreToolHook("b", { phase: HookPhase.EARLY, priority: 50 });
 
-      assert.throws(
-        () => reg.topologicalSort([a]),
-        /Circular dependency detected/,
-      );
+      // Stable sort: same phase + priority means original order is preserved
+      const sorted = reg.topologicalSort([c, a, b]);
+      assert.equal(sorted[0].metadata.name, "c");
+      assert.equal(sorted[1].metadata.name, "a");
+      assert.equal(sorted[2].metadata.name, "b");
     });
 
     it("cross-phase dependencies are ignored (not within same phase)", () => {
@@ -381,6 +327,9 @@ describe("HookRegistry", () => {
 
       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");
     });
 
@@ -462,12 +411,12 @@ describe("HookRegistry", () => {
       assert.equal(result.modifiedOutput, "[[[HELLO]]]");
     });
 
-    it("injects recovery action", async () => {
+    it("injects recovery action (stub)", async () => {
+      // Recovery field removed in cleanup — test kept as placeholder
       const reg = HookRegistry.getInstance();
       reg.registerPostTool(
         makePostToolHook("recovery-test", {}, async () => ({
           result: HookResult.INJECT,
-          injectRecovery: "retry with backoff",
         })),
       );
 
@@ -475,7 +424,83 @@ describe("HookRegistry", () => {
         makeContext(),
         "output",
       );
-      assert.equal(result.recovery, "retry with backoff");
+      assert.equal(result.result, HookResult.INJECT);
+    });
+
+    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");
     });
   });
 
@@ -586,18 +611,6 @@ describe("HookRegistry", () => {
       assert.equal(delegationDepthHook.metadata.phase, HookPhase.NORMAL);
     });
 
-    it("errorRecoveryHook has correct metadata", () => {
-      assert.equal(errorRecoveryHook.metadata.name, "error-recovery");
-      assert.equal(errorRecoveryHook.metadata.priority, 50);
-      assert.equal(errorRecoveryHook.metadata.phase, HookPhase.LATE);
-    });
-
-    it("memorySyncHook has correct metadata", () => {
-      assert.equal(memorySyncHook.metadata.name, "memory-sync");
-      assert.equal(memorySyncHook.metadata.priority, 40);
-      assert.equal(memorySyncHook.metadata.phase, HookPhase.LATE);
-    });
-
     it("shellDetectHook returns shell context", async () => {
       const result = await shellDetectHook.execute(makeContext());
       assert.equal(result.result, HookResult.CONTINUE);
@@ -624,24 +637,6 @@ describe("HookRegistry", () => {
       assert.equal(result.modifiedContext?._depthExceeded, true);
     });
 
-    it("errorRecoveryHook returns CONTINUE for normal output", async () => {
-      const result = await errorRecoveryHook.execute(
-        makeContext(),
-        "Everything completed successfully.",
-      );
-      assert.equal(result.result, HookResult.CONTINUE);
-    });
-
-    it("errorRecoveryHook detects error output", async () => {
-      const result = await errorRecoveryHook.execute(
-        makeContext(),
-        "Error: Failed to connect to server",
-      );
-      assert.equal(result.result, HookResult.INJECT);
-      assert.ok(result.injectRecovery);
-      assert.ok(result.injectRecovery!.includes("Error Recovery"));
-    });
-
     it("confidenceGateHook passes through without confidence info", async () => {
       const result = await confidenceGateHook.execute(
         makeContext(),
@@ -666,12 +661,9 @@ describe("HookRegistry", () => {
       reg.registerPreTool(shellDetectHook);
       reg.registerPreTool(delegationDepthHook);
       reg.registerRoute(confidenceGateHook);
-      reg.registerPostTool(errorRecoveryHook);
-      reg.registerPostTool(memorySyncHook);
 
       assert.equal(reg.getPreToolHooks().length, 3);
       assert.equal(reg.getRouteHooks().length, 1);
-      assert.equal(reg.getPostToolHooks().length, 2);
     });
 
     it("routeTrackingHook has correct metadata", () => {
@@ -692,9 +684,6 @@ describe("HookRegistry", () => {
       // Route hook
       await confidenceGateHook.execute(ctx, "oh-builder");
 
-      // Post-tool hooks
-      await errorRecoveryHook.execute(ctx, "normal output");
-      await memorySyncHook.execute(ctx, "some output");
       // If we got here without throwing, success
       assert.ok(true);
     });
@@ -724,17 +713,9 @@ describe("HookRegistry", () => {
         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.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 () => {
@@ -757,11 +738,7 @@ describe("HookRegistry", () => {
         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.reason.includes("unproductive"));
       });
 
       it("productive hop resets unproductive counter", async () => {
@@ -875,11 +852,7 @@ describe("HookRegistry", () => {
         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.reason.includes("unproductive"));
       });
     });
   });
@@ -952,65 +925,4 @@ describe("HookRegistry", () => {
     });
   });
 
-  // ---------------------------------------------------------------------------
-  // sanityCheckHook
-  // ---------------------------------------------------------------------------
-
-  describe("sanityCheckHook", () => {
-    beforeEach(() => {
-      AnomalyTracker.getInstance().resetAll();
-    });
-
-    it("passes clean output through unchanged", async () => {
-      const ctx = makeContext();
-      const result = await sanityCheckHook.execute(
-        ctx,
-        "Everything is working fine. The system completed the task successfully.",
-      );
-      assert.equal(result.result, HookResult.CONTINUE);
-      assert.equal(result.modifiedOutput, undefined);
-    });
-
-    it("detects repetitive output", async () => {
-      const ctx = makeContext();
-      const line =
-        "Sphinx of black quartz, judge my vow! The five boxing wizards jump quickly. 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-      const repetitiveOutput = Array.from({ length: 20 }, () => line).join("\n");
-      const result = await sanityCheckHook.execute(ctx, repetitiveOutput);
-      // First anomaly — not yet escalated
-      assert.equal(result.result, HookResult.CONTINUE);
-    });
-
-    it("detects box-drawing character flooding", async () => {
-      const ctx = makeContext();
-      const boxArt = "─│┌┐└┘├┤┬┴┼".repeat(50);
-      const result = await sanityCheckHook.execute(ctx, boxArt);
-      assert.equal(result.result, HookResult.CONTINUE);
-    });
-
-    it("detects placeholder patterns", async () => {
-      const ctx = makeContext();
-      // 50× [PLACEHOLDER] = 650 chars, 11 unique → triggers low_diversity check
-      const placeholderText = "[PLACEHOLDER]".repeat(50);
-      const result = await sanityCheckHook.execute(ctx, placeholderText);
-      assert.equal(result.result, HookResult.CONTINUE);
-    });
-
-    it("tracks anomalies across calls", async () => {
-      const ctx = makeContext({ sessionId: "anomaly-escalation-test" });
-      const line =
-        "Sphinx of black quartz, judge my vow! The five boxing wizards jump quickly. 0123456789 ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-      const repetitiveOutput = Array.from({ length: 20 }, () => line).join("\n");
-
-      // First call: anomaly detected but below threshold → CONTINUE
-      const firstResult = await sanityCheckHook.execute(ctx, repetitiveOutput);
-      assert.equal(firstResult.result, HookResult.CONTINUE);
-
-      // Second call: threshold reached → INJECT with recovery
-      const secondResult = await sanityCheckHook.execute(ctx, repetitiveOutput);
-      assert.equal(secondResult.result, HookResult.INJECT);
-      assert.ok(secondResult.injectRecovery);
-      assert.equal(secondResult.modifiedOutput, repetitiveOutput);
-    });
-  });
 });

package/harness/lib/hooks/index.ts

@@ -1,30 +1,38 @@
-// ---------------------------------------------------------------------------
-// Hook System — barrel export
-// ---------------------------------------------------------------------------
-
-export {
-  HookPhase,
-  HookResult,
-} from "./types.ts";
-export type {
-  HookContext,
-  HookMetadata,
-  PreToolUseHook,
-  PostToolUseHook,
-  RouteHook,
-  SessionHook,
-  AnyHook,
-} from "./types.ts";
-
-export { HookRegistry } from "./registry.ts";
-
-// Built-in hooks
-export { planCheckHook } from "./builtins/plan-check-hook.ts";
-export { shellDetectHook } from "./builtins/shell-detect-hook.ts";
-export { confidenceGateHook } from "./builtins/confidence-gate-hook.ts";
-export { delegationDepthHook, resetDepthTracker } from "./builtins/delegation-depth-hook.ts";
-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 { routeTrackingHook, resetRouteTracker, getHopHistory } from "./builtins/route-tracking-hook.ts";
-export type { HopRecord, RouteTrackingConfig } from "./builtins/route-tracking-hook.ts";
+// ---------------------------------------------------------------------------
+// Hook System — barrel export
+// ---------------------------------------------------------------------------
+
+export {
+  HookPhase,
+  HookResult,
+} from "./types.ts";
+export type {
+  HookContextBase,
+  HookContextExtras,
+  HookContext,
+  HookContextPatch,
+  HookMetadata,
+  PreToolUseHook,
+  PostToolUseHook,
+  RouteHook,
+  SessionHook,
+  AnyHook,
+} from "./types.ts";
+
+export { HookRegistry } from "./registry.ts";
+
+// Built-in hooks
+export { planCheckHook } from "./builtins/plan-check-hook.ts";
+export { shellDetectHook } from "./builtins/shell-detect-hook.ts";
+export { confidenceGateHook } from "./builtins/confidence-gate-hook.ts";
+export { delegationDepthHook, resetDepthTracker } from "./builtins/delegation-depth-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";
+
+