openhermes 4.11.2 → 4.13.0

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

@@ -1,107 +0,0 @@
-// ---------------------------------------------------------------------------
-// ErrorRecoveryHook — PostToolUse, priority=50, phase=LATE
-//
-// After sub-agent call, check if output indicates error.
-// Use the RecoveryHandler to match patterns and inject recovery actions.
-// ---------------------------------------------------------------------------
-
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, PostToolUseHook } from "../types.ts";
-import { RecoveryHandler } from "../../recovery/handler.ts";
-import type { ErrorContext } from "../../recovery/interfaces.ts";
-
-export const errorRecoveryHook: PostToolUseHook = {
-  metadata: {
-    name: "error-recovery",
-    priority: 50,
-    phase: HookPhase.LATE,
-    dependencies: [],
-    errorHandling: "isolate",
-  },
-
-  async execute(context: HookContext, output: string) {
-    // Check if the output looks like an error
-    const isErrorOutput = looksLikeError(output);
-    if (!isErrorOutput) {
-      return { result: HookResult.CONTINUE };
-    }
-
-    // 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 action = handler.handleError(errorContext);
-
-    // Build a recovery instruction based on the action
-    const recoveryInstruction = buildRecoveryInstruction(action);
-
-    return {
-      result: HookResult.INJECT,
-      modifiedOutput: output,
-      injectRecovery: recoveryInstruction,
-    };
-  },
-};
-
-/**
- * Heuristic check: does the output look like an error?
- * Looks for common error patterns in tool output.
- */
-function looksLikeError(output: string): boolean {
-  if (!output || output.length === 0) return false;
-
-  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,
-    /context.?length/i,
-    /token.?limit/i,
-    /parse.?error/i,
-    /syntax.?error/i,
-    /timeout/i,
-    /execution.?timed.?out/i,
-  ];
-
-  // Check first 2000 chars to avoid false positives in long output
-  const head = output.slice(0, 2000);
-  return errorPatterns.some((p) => p.test(head));
-}
-
-/**
- * Build a recovery instruction string from a RecoveryAction.
- */
-function buildRecoveryInstruction(
-  action: { type: string; delay?: number; maxAttempts?: number; reason: string; modifyPrompt?: string },
-): string {
-  const parts: string[] = [
-    `[HOOK: Error Recovery]`,
-    `Action: ${action.type}`,
-    `Reason: ${action.reason}`,
-  ];
-
-  if (action.delay) {
-    parts.push(`Delay: ${action.delay}ms before retry`);
-  }
-  if (action.maxAttempts) {
-    parts.push(`Max attempts: ${action.maxAttempts}`);
-  }
-  if (action.modifyPrompt) {
-    parts.push(`Modification: ${action.modifyPrompt}`);
-  }
-
-  return parts.join("\n");
-}

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

@@ -1,73 +0,0 @@
-// ---------------------------------------------------------------------------
-// MemorySyncHook — PostToolUse, priority=40, phase=LATE
-//
-// After each step, sync memory entries to plan file.
-// Uses MemoryManager from harness/lib/memory/memory-manager.ts
-// ---------------------------------------------------------------------------
-
-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 { MemoryLevel } from "../../memory/interfaces.ts";
-
-export const memorySyncHook: PostToolUseHook = {
-  metadata: {
-    name: "memory-sync",
-    priority: 40,
-    phase: HookPhase.LATE,
-    dependencies: [],
-    errorHandling: "isolate",
-  },
-
-  async execute(context: HookContext, output: string) {
-    // Sync memory entries to plan file
-    const planFile = findLatestPlanFile(context.directory);
-    if (!planFile) {
-      // No plan file to sync to — skip silently
-      return { result: HookResult.CONTINUE };
-    }
-
-    const mem = MemoryManager.getInstance();
-
-    // Extract findings from the session memory (TASK level)
-    const taskEntries = mem.getEntries(MemoryLevel.TASK);
-
-    // Sync important task entries as plan findings
-    for (const entry of taskEntries) {
-      if (entry.importance >= 0.6) {
-        try {
-          await PlanStore.addFinding(planFile, context.sessionId, {
-            description: entry.content,
-            severity: entry.importance >= 0.8 ? "warning" : "info",
-          });
-        } catch {
-          // Plan sync is best-effort — don't break execution
-        }
-      }
-    }
-
-    // Sync any decisions
-    const missionEntries = mem.getEntries(MemoryLevel.MISSION);
-    for (const entry of missionEntries) {
-      if (entry.metadata?.type === "decision" && entry.importance >= 0.7) {
-        try {
-          await PlanStore.addDecision(planFile, context.sessionId, {
-            description: entry.content,
-            rationale: (entry.metadata.rationale as string) ?? "Auto-synced decision",
-          });
-        } catch {
-          // Best-effort
-        }
-      }
-    }
-
-    return {
-      result: HookResult.CONTINUE,
-      modifiedContext: {
-        _memorySyncCount: taskEntries.filter((e) => e.importance >= 0.6).length,
-      },
-    };
-  },
-};

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

@@ -1,52 +0,0 @@
-// ---------------------------------------------------------------------------
-// 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/memory/index.ts

@@ -1,18 +0,0 @@
-// ---------------------------------------------------------------------------
-// Memory module — barrel export
-// ---------------------------------------------------------------------------
-
-export {
-  MemoryLevel,
-  DEFAULT_BUDGETS,
-} from "./interfaces.ts";
-export type {
-  MemoryEntry,
-  MemorySnapshot,
-  MemoryConfig,
-  Finding,
-  Decision,
-} from "./interfaces.ts";
-
-export { MemoryManager } from "./memory-manager.ts";
-export { PlanStore } from "./plan-store.ts";

package/harness/lib/memory/interfaces.ts

@@ -1,53 +0,0 @@
-// ---------------------------------------------------------------------------
-// 4-Tier Memory System — interfaces & types
-// ---------------------------------------------------------------------------
-
-export enum MemoryLevel {
-  SYSTEM = "system",    // immutable OpenHermes identity, never pruned
-  PROJECT = "project",  // project-level config, conventions, decisions
-  MISSION = "mission",  // current session goal, active plan reference
-  TASK = "task",        // per-step findings, cleared after each iteration
-}
-
-export interface MemoryEntry {
-  id: string;
-  level: MemoryLevel;
-  content: string;
-  timestamp: number;
-  importance: number;  // 0.0 to 1.0
-  metadata?: Record<string, string>;
-}
-
-export interface MemorySnapshot {
-  system: MemoryEntry[];
-  project: MemoryEntry[];
-  mission: MemoryEntry[];
-  task: MemoryEntry[];
-}
-
-export interface MemoryConfig {
-  budgets: Partial<Record<MemoryLevel, number>>;  // max entries per level, defaults filled for missing
-}
-
-export interface Finding {
-  id: string;
-  sessionId: string;
-  description: string;
-  severity: "info" | "warning" | "blocker";
-  timestamp: number;
-}
-
-export interface Decision {
-  id: string;
-  sessionId: string;
-  description: string;
-  rationale: string;
-  timestamp: number;
-}
-
-export const DEFAULT_BUDGETS: Record<MemoryLevel, number> = {
-  [MemoryLevel.SYSTEM]: 50,
-  [MemoryLevel.PROJECT]: 100,
-  [MemoryLevel.MISSION]: 30,
-  [MemoryLevel.TASK]: 20,
-};

package/harness/lib/memory/memory-manager.ts

@@ -1,205 +0,0 @@
-// ---------------------------------------------------------------------------
-// MemoryManager — singleton 4-tier hierarchical memory store
-// ---------------------------------------------------------------------------
-
-import { randomUUID } from "node:crypto";
-import {
-  MemoryLevel,
-  DEFAULT_BUDGETS,
-} from "./interfaces.ts";
-import type {
-  MemoryEntry,
-  MemorySnapshot,
-  MemoryConfig,
-} from "./interfaces.ts";
-
-// ---------------------------------------------------------------------------
-// Manager
-// ---------------------------------------------------------------------------
-
-export class MemoryManager {
-  private static instance: MemoryManager;
-
-  private entries: Map<MemoryLevel, MemoryEntry[]> = new Map();
-  private config: MemoryConfig;
-
-  private constructor(config?: Partial<MemoryConfig>) {
-    this.config = {
-      budgets: { ...DEFAULT_BUDGETS, ...config?.budgets },
-    };
-    // Initialise every level so callers never hit undefined
-    for (const level of Object.values(MemoryLevel)) {
-      this.entries.set(level, []);
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // Singleton
-  // -----------------------------------------------------------------------
-
-  static getInstance(config?: Partial<MemoryConfig>): MemoryManager {
-    if (!MemoryManager.instance) {
-      MemoryManager.instance = new MemoryManager(config);
-    }
-    return MemoryManager.instance;
-  }
-
-  /** Reset singleton — used in tests for isolation. */
-  static resetInstance(): void {
-    MemoryManager.instance = null as unknown as MemoryManager;
-  }
-
-  // -----------------------------------------------------------------------
-  // Public API
-  // -----------------------------------------------------------------------
-
-  /**
-   * Add a memory entry at the given level.
-   * Inserts, sorts by importance DESC then timestamp DESC, then prunes.
-   */
-  add(
-    level: MemoryLevel,
-    content: string,
-    importance: number,
-    metadata?: Record<string, string>,
-  ): MemoryEntry {
-    const entry: MemoryEntry = {
-      id: randomUUID(),
-      level,
-      content,
-      timestamp: Date.now(),
-      importance: Math.max(0, Math.min(1, importance)), // clamp [0, 1]
-      metadata,
-    };
-
-    const bucket = this.entries.get(level)!;
-    bucket.push(entry);
-
-    // Sort: importance DESC, then timestamp DESC (newer first for ties)
-    bucket.sort((a, b) => {
-      if (b.importance !== a.importance) return b.importance - a.importance;
-      return b.timestamp - a.timestamp;
-    });
-
-    this.prune(level);
-    return entry;
-  }
-
-  /**
-   * Return a formatted context string for all levels.
-   * If a query string is provided, only entries whose content includes
-   * the query (case-insensitive) are returned.
-   */
-  getContext(query?: string): string {
-    const parts: string[] = [];
-
-    for (const level of Object.values(MemoryLevel)) {
-      const bucket = this.entries.get(level) ?? [];
-      let filtered = bucket;
-
-      if (query && query.length > 0) {
-        const q = query.toLowerCase();
-        filtered = bucket.filter((e) => e.content.toLowerCase().includes(q));
-      }
-
-      if (filtered.length === 0) continue;
-
-      const heading = level.toUpperCase();
-      const lines = filtered.map((e) => {
-        const imp = e.importance.toFixed(2);
-        const meta = e.metadata ? ` [${formatMetadata(e.metadata)}]` : "";
-        return `  [${imp}] ${e.content}${meta}`;
-      });
-
-      parts.push(`== ${heading} ==\n${lines.join("\n")}`);
-    }
-
-    return parts.join("\n\n");
-  }
-
-  /**
-   * Remove the least important entries from a level when budget is exceeded.
-   * Falls back to DEFAULT_BUDGETS if no explicit budget is configured.
-   */
-  prune(level: MemoryLevel): void {
-    const budget = this.config.budgets[level] ?? DEFAULT_BUDGETS[level];
-
-    // Guard: budget must be a valid non-negative number
-    if (typeof budget !== "number" || budget < 0 || !Number.isFinite(budget)) {
-      console.warn(
-        `[MemoryManager] Invalid budget for level "${level}": ${budget}. Skipping prune.`,
-      );
-      return;
-    }
-
-    const bucket = this.entries.get(level);
-    if (!bucket) return;
-    if (bucket.length <= budget) return;
-
-    // Already sorted: importance DESC → drop from the end
-    bucket.splice(budget);
-  }
-
-  /** Clear all entries at a given level (used for TASK after iteration). */
-  clearLevel(level: MemoryLevel): void {
-    this.entries.set(level, []);
-  }
-
-  /** Serialise all entries into a snapshot. */
-  export(): MemorySnapshot {
-    return {
-      system: [...(this.entries.get(MemoryLevel.SYSTEM) ?? [])],
-      project: [...(this.entries.get(MemoryLevel.PROJECT) ?? [])],
-      mission: [...(this.entries.get(MemoryLevel.MISSION) ?? [])],
-      task: [...(this.entries.get(MemoryLevel.TASK) ?? [])],
-    };
-  }
-
-  /** Restore state from a snapshot. */
-  import(snapshot: MemorySnapshot): void {
-    this.entries.set(MemoryLevel.SYSTEM, [...snapshot.system]);
-    this.entries.set(MemoryLevel.PROJECT, [...snapshot.project]);
-    this.entries.set(MemoryLevel.MISSION, [...snapshot.mission]);
-    this.entries.set(MemoryLevel.TASK, [...snapshot.task]);
-  }
-
-  /** Get entries, optionally filtered by level. */
-  getEntries(level?: MemoryLevel): MemoryEntry[] {
-    if (level) {
-      return [...(this.entries.get(level) ?? [])];
-    }
-    const all: MemoryEntry[] = [];
-    for (const lvl of Object.values(MemoryLevel)) {
-      all.push(...(this.entries.get(lvl) ?? []));
-    }
-    return all;
-  }
-
-  /** Count entries at a given level. */
-  getEntryCount(level: MemoryLevel): number {
-    return this.entries.get(level)?.length ?? 0;
-  }
-
-  /** Update the budgets after construction. */
-  setBudgets(budgets: Partial<Record<MemoryLevel, number>>): void {
-    for (const [level, budget] of Object.entries(budgets)) {
-      if (budget !== undefined && Object.values(MemoryLevel).includes(level as MemoryLevel)) {
-        this.config.budgets[level as MemoryLevel] = budget;
-      }
-    }
-    // Re-prune all levels with new budgets
-    for (const level of Object.values(MemoryLevel)) {
-      this.prune(level);
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function formatMetadata(meta: Record<string, string>): string {
-  return Object.entries(meta)
-    .map(([k, v]) => `${k}=${v}`)
-    .join(", ");
-}