openhermes 4.9.2 → 4.12.1

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

@@ -0,0 +1,201 @@
+// ---------------------------------------------------------------------------
+// RouteTrackingHook — RouteHook, priority=55, phase=LATE
+//
+// Loop guard — mechanically enforce two limits:
+// 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
+// ---------------------------------------------------------------------------
+
+export interface HopRecord {
+  skill: string;
+  timestamp: number;
+  producedArtifact: boolean;
+}
+
+export interface RouteTrackingConfig {
+  maxSkillRepeats: number;
+  maxUnproductiveHops: number;
+  artifactCheck: (route: string) => boolean | Promise<boolean>;
+}
+
+interface RouteTrackingState {
+  hops: HopRecord[];
+  skillCounts: Map<string, number>;
+  unproductiveCount: number;
+}
+
+// ---------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+
+const sessionStates = new Map<string, RouteTrackingState>();
+
+export function resetRouteTracker(sessionId?: string): void {
+  if (sessionId) {
+    sessionStates.delete(sessionId);
+  } else {
+    sessionStates.clear();
+  }
+}
+
+export function getHopHistory(sessionId: string): HopRecord[] {
+  return sessionStates.get(sessionId)?.hops ?? [];
+}
+
+// ---------------------------------------------------------------------------
+// Default artifact check (conservative — assumes unproductive)
+// ---------------------------------------------------------------------------
+
+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
+// ---------------------------------------------------------------------------
+
+export const routeTrackingHook: RouteHook = {
+  metadata: {
+    name: "route-tracking",
+    priority: 55,
+    phase: HookPhase.LATE,
+    dependencies: [],
+    errorHandling: "propagate",
+  },
+
+  async execute(context: HookContext, route: string) {
+    // Skip terminal routes — they don't count as routing hops
+    const terminalRoutes = new Set(["surface", "done", "oh-handoff"]);
+    if (terminalRoutes.has(route)) {
+      return { result: HookResult.CONTINUE, modifiedRoute: route };
+    }
+
+    const sessionId = context.sessionId;
+
+    // Get or create state for this session
+    let state = sessionStates.get(sessionId);
+    if (!state) {
+      state = {
+        hops: [],
+        skillCounts: new Map<string, number>(),
+        unproductiveCount: 0,
+      };
+      sessionStates.set(sessionId, state);
+    }
+
+    // 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);
+    const hop: HopRecord = {
+      skill: route,
+      timestamp: Date.now(),
+      producedArtifact,
+    };
+    state.hops.push(hop);
+
+    // Update skill count
+    const currentSkillCount = (state.skillCounts.get(route) ?? 0) + 1;
+    state.skillCounts.set(route, currentSkillCount);
+
+    // Update unproductive counter (resets on any productive hop)
+    if (producedArtifact) {
+      state.unproductiveCount = 0;
+    } else {
+      state.unproductiveCount += 1;
+    }
+
+    // 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 — 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/sanity-check-hook.ts

@@ -0,0 +1,52 @@
+// ---------------------------------------------------------------------------
+// SanityCheckHook — PostToolUse, priority=30, phase=LATE
+//
+// After each tool invocation, check the output for LLM degeneration patterns
+// (repetition, low diversity, gibberish, etc.). Track consecutive anomalies
+// per session. If 2+ consecutive anomalies detected, inject a recovery
+// instruction to compact/refresh context before it cascades.
+// ---------------------------------------------------------------------------
+
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PostToolUseHook } from "../types.ts";
+import { checkOutputSanity } from "../../sanity/checker.ts";
+import { AnomalyTracker } from "../../sanity/anomaly-tracker.ts";
+
+export const sanityCheckHook: PostToolUseHook = {
+  metadata: {
+    name: "sanity-check",
+    priority: 30,
+    phase: HookPhase.LATE,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext, output: string) {
+    const sessionId = context.sessionId;
+
+    // Run the sanity checker on the output
+    const result = checkOutputSanity(output);
+
+    // Record the result in the anomaly tracker
+    const tracker = AnomalyTracker.getInstance();
+    const tracking = tracker.record(sessionId, result);
+
+    if (result.isHealthy) {
+      // Output is healthy — no action needed
+      return { result: HookResult.CONTINUE };
+    }
+
+    // Unhealthy output detected
+    if (tracking.shouldEscalate) {
+      // Escalation threshold reached — inject recovery instruction
+      return {
+        result: HookResult.INJECT,
+        modifiedOutput: output,
+        injectRecovery: tracking.recoveryMessage ?? "recovery: compact context",
+      };
+    }
+
+    // First anomaly (below threshold) — let it pass with a warning
+    return { result: HookResult.CONTINUE };
+  },
+};

package/harness/lib/hooks/builtins/shell-detect-hook.ts

@@ -0,0 +1,96 @@
+// ---------------------------------------------------------------------------
+// ShellDetectHook — PreToolUse, priority=80, phase=EARLY
+//
+// Before sub-agent calls that need CLI, inject SHELL.md preamble.
+// Detect platform, add appropriate shell context.
+// ---------------------------------------------------------------------------
+
+import { HookPhase, HookResult } from "../types.ts";
+import type { HookContext, PreToolUseHook } from "../types.ts";
+import { getHarnessDir } from "../../../../lib/harness-resolver.ts";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export const shellDetectHook: PreToolUseHook = {
+  metadata: {
+    name: "shell-detect",
+    priority: 80,
+    phase: HookPhase.EARLY,
+    dependencies: [],
+    errorHandling: "isolate",
+  },
+
+  async execute(context: HookContext) {
+    const platform = os.platform();
+    const isWindows = platform === "win32";
+
+    // Detect shell type
+    let shellType = "unknown";
+    if (isWindows) {
+      // On Windows: detect PowerShell, CMD, or Git Bash
+      const comSpec = process.env.COMSPEC ?? "";
+      if (process.env.PSModulePath || process.env.PSExecutionPolicy) {
+        shellType = "powershell";
+      } else if (comSpec.toLowerCase().includes("cmd")) {
+        shellType = "cmd";
+      } else {
+        // Could be Git Bash
+        shellType = process.env.BASH ? "bash" : "powershell";
+      }
+    } else {
+      shellType = "bash";
+    }
+
+    // Try to load SHELL.md
+    let shellPreamble = "";
+    try {
+      const shellDocPath = path.join(getHarnessDir(), "instructions", "SHELL.md");
+      await fs.promises.access(shellDocPath);
+      shellPreamble = (await fs.promises.readFile(shellDocPath, "utf8")).trim();
+    } catch {
+      // If SHELL.md can't be read, provide minimal preamble
+      shellPreamble = "";
+    }
+
+    return {
+      result: HookResult.CONTINUE,
+      modifiedContext: {
+        _shellPlatform: platform,
+        _shellType: shellType,
+        _shellPreamble: shellPreamble || getDefaultPreamble(shellType, platform),
+      },
+    };
+  },
+};
+
+function getDefaultPreamble(shellType: string, _platform: string): string {
+  if (shellType === "powershell") {
+    return [
+      "## Shell Environment",
+      "",
+      "Detected: PowerShell on Windows",
+      "- File ops, scoop installs, ps1 scripts, env vars → PowerShell",
+      "- git, bun, npm, node → any shell (all work)",
+      "- rm -rf, make, unix scripts → Git Bash",
+      "",
+    ].join("\n");
+  }
+  if (shellType === "cmd") {
+    return [
+      "## Shell Environment",
+      "",
+      "Detected: CMD on Windows",
+      "- .bat/.cmd scripts → CMD",
+      "- git, bun, npm, node → any shell",
+      "",
+    ].join("\n");
+  }
+  return [
+    "## Shell Environment",
+    "",
+    `Detected: ${shellType}`,
+    "- Standard POSIX shell commands available",
+    "",
+  ].join("\n");
+}

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 };
+  },
+};