openhermes 4.12.1 → 4.13.0

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

@@ -4,45 +4,41 @@
 
 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,
-  dynamicRouteHook,
-} from "./index.ts";
-import { AnomalyTracker } from "../sanity/anomaly-tracker.ts";
-import type {
-  HookContext,
-  HookContextPatch,
-  HookMetadata,
-  PreToolUseHook,
-  PostToolUseHook,
-  RouteHook,
+  routeTrackingHook,
+  resetRouteTracker,
+  getHopHistory,
+  dynamicRouteHook,
+} from "./index.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";
+} from "./types.ts";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 
-function makeContext(overrides?: HookContextPatch): 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,
@@ -52,13 +48,13 @@ function makeContext(overrides?: HookContextPatch): HookContext {
 function makePreToolHook(
   name: string,
   overrides?: Partial<HookMetadata>,
-  impl?: (
-    ctx: HookContext,
-  ) => Promise<{
-    result: HookResult;
-    modifiedContext?: HookContextPatch;
-  }>,
-): PreToolUseHook {
+  impl?: (
+    ctx: HookContext,
+  ) => Promise<{
+    result: HookResult;
+    modifiedContext?: HookContextPatch;
+  }>,
+): PreToolUseHook {
   return {
     metadata: {
       name,
@@ -81,7 +77,6 @@ function makePostToolHook(
   ) => Promise<{
     result: HookResult;
     modifiedOutput?: string;
-    injectRecovery?: string;
   }>,
 ): PostToolUseHook {
   return {
@@ -140,18 +135,18 @@ function makeSessionHook(
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("HookRegistry", () => {
-  const tmpDirs: string[] = [];
-
-  after(() => {
-    for (const dir of tmpDirs) {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  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();
   });
 
@@ -264,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,
@@ -273,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)", () => {
@@ -392,13 +325,13 @@ 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");
-    });
+      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();
@@ -443,7 +376,7 @@ describe("HookRegistry", () => {
     });
   });
 
-  describe("executePostTool", () => {
+  describe("executePostTool", () => {
     it("passes through output without modification", async () => {
       const reg = HookRegistry.getInstance();
       reg.registerPostTool(makePostToolHook("pass"));
@@ -478,98 +411,98 @@ describe("HookRegistry", () => {
       assert.equal(result.modifiedOutput, "[[[HELLO]]]");
     });
 
-    it("injects recovery action", async () => {
-      const reg = HookRegistry.getInstance();
-      reg.registerPostTool(
+    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",
         })),
       );
 
       const result = await reg.executePostTool(
         makeContext(),
         "output",
-      );
-      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");
-    });
-  });
+      );
+      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");
+    });
+  });
 
   describe("executeRoute", () => {
     it("passes route unchanged", async () => {
@@ -678,18 +611,6 @@ route:
       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);
@@ -716,24 +637,6 @@ route:
       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(),
@@ -758,12 +661,9 @@ route:
       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", () => {
@@ -784,9 +684,6 @@ route:
       // 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);
     });
@@ -815,10 +712,10 @@ route:
         // 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.reason);
-        assert.ok(ctx._optiRoute.reason.includes("oh-builder"));
-        assert.ok(ctx._optiRoute.chain.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 () => {
@@ -840,8 +737,8 @@ route:
         // 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.reason.includes("unproductive"));
+        assert.ok(ctx._optiRoute);
+        assert.ok(ctx._optiRoute.reason.includes("unproductive"));
       });
 
       it("productive hop resets unproductive counter", async () => {
@@ -954,9 +851,9 @@ route:
         // 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.reason.includes("unproductive"));
-      });
+        assert.ok(ctx._optiRoute);
+        assert.ok(ctx._optiRoute.reason.includes("unproductive"));
+      });
     });
   });
 
@@ -1028,65 +925,4 @@ route:
     });
   });
 
-  // ---------------------------------------------------------------------------
-  // 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);
-    });
-  });
 });