whale-code 6.5.6 → 6.5.8

package/dist/shared/agent-core-loop-errors.test.js

@@ -0,0 +1,258 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
+
+// ============================================================================
+// LoopDetector — recordResult, endTurn, session errors, transient errors
+// ============================================================================
+
+describe("LoopDetector (errors and turns)", () => {
+  let detector;
+  beforeEach(() => {
+    detector = new LoopDetector();
+  });
+  describe("recordResult -- consecutive error tracking", () => {
+    it("blocks after CONSECUTIVE_ERROR_LIMIT consecutive errors for same tool", () => {
+      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
+        detector.recordCall("bash", {
+          command: "fail"
+        });
+        detector.recordResult("bash", false);
+      }
+      const result = detector.recordCall("bash", {
+        command: "different"
+      });
+      expect(result.blocked).toBe(true);
+      expect(result.reason).toContain("failed");
+      expect(result.reason).toContain("consecutively");
+    });
+    it("resets consecutive errors on success", () => {
+      // Fail twice
+      detector.recordCall("bash", {
+        command: "fail"
+      });
+      detector.recordResult("bash", false);
+      detector.recordCall("bash", {
+        command: "fail2"
+      });
+      detector.recordResult("bash", false);
+
+      // Succeed once -- resets counter
+      detector.recordCall("bash", {
+        command: "ok"
+      });
+      detector.recordResult("bash", true);
+
+      // Should be able to fail again without being blocked
+      detector.recordCall("bash", {
+        command: "fail3"
+      });
+      detector.recordResult("bash", false);
+      const result = detector.recordCall("bash", {
+        command: "new"
+      });
+      expect(result.blocked).toBe(false);
+    });
+  });
+  describe("recordResult -- turn error limit", () => {
+    it("blocks after TURN_ERROR_LIMIT errors in a single turn", () => {
+      for (let i = 0; i < AGENT_DEFAULTS.loopTurnErrorLimit; i++) {
+        detector.recordCall(`tool${i}`, {
+          arg: i
+        });
+        detector.recordResult(`tool${i}`, false);
+      }
+      const result = detector.recordCall("another_tool", {
+        arg: "x"
+      });
+      expect(result.blocked).toBe(true);
+      expect(result.reason).toContain("errors this turn");
+    });
+  });
+  describe("recordResult -- failed strategy tracking", () => {
+    it("blocks exact same call that previously failed", () => {
+      detector.recordCall("edit_file", {
+        path: "/x",
+        content: "y"
+      });
+      detector.recordResult("edit_file", false, {
+        path: "/x",
+        content: "y"
+      });
+
+      // Reset turn to simulate new turn
+      detector.resetTurn();
+      const result = detector.recordCall("edit_file", {
+        path: "/x",
+        content: "y"
+      });
+      expect(result.blocked).toBe(true);
+      expect(result.reason).toContain("failed in a previous turn");
+    });
+  });
+  describe("session error tracking", () => {
+    it("blocks tool after SESSION_TOOL_ERROR_LIMIT failures", () => {
+      for (let i = 0; i < AGENT_DEFAULTS.loopSessionToolErrorLimit; i++) {
+        detector.recordCall("bad_tool", {
+          attempt: i
+        });
+        detector.recordResult("bad_tool", false);
+        detector.resetTurn(); // reset turn errors to avoid turn limit
+      }
+      const result = detector.recordCall("bad_tool", {
+        attempt: "final"
+      });
+      expect(result.blocked).toBe(true);
+      expect(result.reason).toContain("failed");
+      expect(result.reason).toContain("times this session");
+    });
+  });
+  describe("endTurn -- bail detection", () => {
+    it("does not bail after successful turns", () => {
+      for (let i = 0; i < 5; i++) {
+        detector.recordCall("tool", {
+          i
+        });
+        detector.recordResult("tool", true);
+        const bail = detector.endTurn();
+        expect(bail.shouldBail).toBe(false);
+        detector.resetTurn();
+      }
+    });
+    it("bails after CONSECUTIVE_FAILED_TURN_LIMIT failed turns", () => {
+      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; i++) {
+        detector.recordCall("tool", {
+          i
+        });
+        detector.recordResult("tool", false);
+        const bail = detector.endTurn();
+        if (i < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit - 1) {
+          expect(bail.shouldBail).toBe(false);
+        } else {
+          expect(bail.shouldBail).toBe(true);
+          expect(bail.message).toContain("consecutive turns");
+        }
+        detector.resetTurn();
+      }
+    });
+    it("resets consecutive failed turns on a successful turn", () => {
+      // 2 failed turns
+      for (let i = 0; i < 2; i++) {
+        detector.recordCall("tool", {
+          i
+        });
+        detector.recordResult("tool", false);
+        detector.endTurn();
+        detector.resetTurn();
+      }
+
+      // 1 successful turn
+      detector.recordCall("tool", {
+        ok: true
+      });
+      detector.recordResult("tool", true);
+      detector.endTurn();
+      detector.resetTurn();
+
+      // More failed turns should not trigger bail yet
+      detector.recordCall("tool", {
+        fail: true
+      });
+      detector.recordResult("tool", false);
+      const bail = detector.endTurn();
+      expect(bail.shouldBail).toBe(false);
+    });
+  });
+  describe("endTurn -- caps consecutiveErrors to prevent parallel batch deadlock", () => {
+    it("caps consecutiveErrors at (limit - 1) so tool gets one retry next turn", () => {
+      // Simulate 7 parallel failures from one batch (the TOCTOU race scenario)
+      for (let i = 0; i < 7; i++) {
+        detector.recordCall("read_file", {
+          path: `/file-${i}`
+        });
+        detector.recordResult("read_file", false);
+      }
+
+      // At this point, consecutiveErrors["read_file"] = 7 which exceeds the limit of 3.
+      // The tool would be permanently blocked without the cap fix.
+      const bail = detector.endTurn();
+      expect(bail.shouldBail).toBe(false); // only 1 failed turn, not 3
+
+      // After endTurn caps consecutiveErrors, the tool should be retryable
+      detector.resetTurn();
+      const result = detector.recordCall("read_file", {
+        path: "/new-path"
+      });
+      expect(result.blocked).toBe(false); // tool gets one more chance
+    });
+    it("does NOT cap consecutiveErrors when at the bail-out threshold", () => {
+      // Simulate 3 consecutive failed turns to hit the bail-out limit
+      for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; turn++) {
+        detector.recordCall("tool", {
+          turn
+        });
+        detector.recordResult("tool", false);
+        detector.endTurn();
+        detector.resetTurn();
+      }
+
+      // After bail-out, consecutive errors are NOT capped -- tool stays blocked
+      const result = detector.recordCall("tool", {
+        retry: true
+      });
+      expect(result.blocked).toBe(true);
+    });
+  });
+  describe("transient errors", () => {
+    it("does not add transient failures to failedStrategies", () => {
+      detector.recordCall("task_output", {
+        task_id: "abc"
+      });
+      detector.recordResult("task_output", false, {
+        task_id: "abc"
+      }, true);
+      const stats = detector.getSessionStats();
+      expect(stats.totalErrors).toBe(1);
+      expect(stats.failedStrategies).toBe(0);
+
+      // Same call should NOT be blocked on retry
+      detector.resetTurn();
+      const check = detector.recordCall("task_output", {
+        task_id: "abc"
+      });
+      expect(check.blocked).toBe(false);
+    });
+    it("adds non-transient failures to failedStrategies (default)", () => {
+      detector.recordCall("edit_file", {
+        path: "/x"
+      });
+      detector.recordResult("edit_file", false, {
+        path: "/x"
+      });
+      const stats = detector.getSessionStats();
+      expect(stats.failedStrategies).toBe(1);
+
+      // Same call should be blocked
+      detector.resetTurn();
+      const check = detector.recordCall("edit_file", {
+        path: "/x"
+      });
+      expect(check.blocked).toBe(true);
+    });
+    it("still counts transient errors toward consecutive/turn limits", () => {
+      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
+        detector.recordCall("task_output", {
+          task_id: "abc"
+        });
+        detector.recordResult("task_output", false, {
+          task_id: "abc"
+        }, true);
+      }
+
+      // Should be blocked by consecutiveErrorLimit even though transient
+      const check = detector.recordCall("task_output", {
+        task_id: "abc"
+      });
+      expect(check.blocked).toBe(true);
+    });
+  });
+});

package/dist/shared/agent-core-loop.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Agent Core Loop — LoopDetector, ToolChoice resolution
+ * Extracted from agent-core.ts for modularity.
+ * resolveAgentLoopConfig moved to agent-core-config.ts to keep this under 300 lines.
+ */
+import { type LoopCheckResult, type BailCheckResult, type ToolChoice, type LoopDetectorConfig, type ResolvedAgentLoopConfig } from "./agent-core-types.js";
+/**
+ * Resolve the effective tool_choice for a given turn.
+ *
+ * Priority:
+ * 1. Explicit override from caller (toolChoice option)
+ * 2. Loop detection: if last 3 turns all used the same tool, force "none"
+ * 3. Keyword detection: if user message mentions a tool name, force that tool
+ * 4. Default: "auto"
+ */
+export declare function resolveToolChoice(opts: {
+    toolChoice?: ToolChoice;
+    turnCount: number;
+    recentToolUses: string[];
+    availableToolNames: string[];
+    userMessage: string;
+}): ToolChoice;
+/** djb2 string hash — fast, deterministic, no dependencies */
+export declare function djb2Hash(str: string): string;
+export declare class LoopDetector {
+    private history;
+    private consecutiveErrors;
+    private turnErrors;
+    private turnHadErrors;
+    private sessionErrors;
+    private failedStrategies;
+    private consecutiveFailedTurns;
+    private totalSessionErrors;
+    /** Tracks how many times the same file path has been read this session */
+    private fileReadCounts;
+    /** Resolved config — accepts DB overrides, falls back to AGENT_DEFAULTS */
+    readonly config: LoopDetectorConfig;
+    constructor(config?: Partial<LoopDetectorConfig>);
+    /** Create a LoopDetector from a ResolvedAgentLoopConfig */
+    static fromResolved(resolved: ResolvedAgentLoopConfig): LoopDetector;
+    private errorKey;
+    recordCall(name: string, input: Record<string, unknown>): LoopCheckResult;
+    trackRead(path: string): LoopCheckResult;
+    recordResult(name: string, success: boolean, input?: Record<string, unknown>, transient?: boolean): void;
+    endTurn(): BailCheckResult;
+    resetTurn(): void;
+    reset(): void;
+    getSessionStats(): {
+        totalErrors: number;
+        failedStrategies: number;
+        consecutiveFailedTurns: number;
+    };
+}

package/dist/shared/agent-core-loop.js

@@ -0,0 +1,251 @@
+/**
+ * Agent Core Loop — LoopDetector, ToolChoice resolution
+ * Extracted from agent-core.ts for modularity.
+ * resolveAgentLoopConfig moved to agent-core-config.ts to keep this under 300 lines.
+ */
+
+import { AGENT_DEFAULTS } from "./agent-core-types.js";
+
+// ============================================================================
+// TOOL CHOICE RESOLUTION
+// ============================================================================
+
+/**
+ * Resolve the effective tool_choice for a given turn.
+ *
+ * Priority:
+ * 1. Explicit override from caller (toolChoice option)
+ * 2. Loop detection: if last 3 turns all used the same tool, force "none"
+ * 3. Keyword detection: if user message mentions a tool name, force that tool
+ * 4. Default: "auto"
+ */
+export function resolveToolChoice(opts) {
+  if (opts.toolChoice !== undefined) return opts.toolChoice;
+  if (opts.recentToolUses.length >= 3) {
+    const last3 = opts.recentToolUses.slice(-3);
+    if (last3[0] === last3[1] && last3[1] === last3[2]) {
+      return "none";
+    }
+  }
+  if (opts.recentToolUses.length >= 6) {
+    const last6 = opts.recentToolUses.slice(-6);
+    const isRepeatingPair = last6[2] === last6[0] && last6[3] === last6[1] && last6[4] === last6[0] && last6[5] === last6[1];
+    if (isRepeatingPair) return "none";
+  }
+  if (opts.turnCount === 1 && opts.userMessage && opts.availableToolNames.length > 0) {
+    const msgLower = opts.userMessage.toLowerCase();
+    for (const toolName of opts.availableToolNames) {
+      if (toolName.length >= 4 && msgLower.includes(toolName.toLowerCase())) {
+        return {
+          type: "tool",
+          name: toolName
+        };
+      }
+    }
+  }
+  return "auto";
+}
+
+// ============================================================================
+// LOOP DETECTION
+// ============================================================================
+
+/** djb2 string hash — fast, deterministic, no dependencies */
+export function djb2Hash(str) {
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) & 0xffffffff;
+  }
+  return hash.toString(36);
+}
+export class LoopDetector {
+  history = [];
+  consecutiveErrors = new Map();
+  turnErrors = 0;
+  turnHadErrors = false;
+  sessionErrors = new Map();
+  failedStrategies = new Set();
+  consecutiveFailedTurns = 0;
+  totalSessionErrors = 0;
+
+  /** Tracks how many times the same file path has been read this session */
+  fileReadCounts = new Map();
+
+  /** Resolved config — accepts DB overrides, falls back to AGENT_DEFAULTS */
+
+  constructor(config) {
+    this.config = {
+      identicalCallLimit: config?.identicalCallLimit ?? AGENT_DEFAULTS.loopIdenticalCallLimit,
+      consecutiveErrorLimit: config?.consecutiveErrorLimit ?? AGENT_DEFAULTS.loopConsecutiveErrorLimit,
+      turnErrorLimit: config?.turnErrorLimit ?? AGENT_DEFAULTS.loopTurnErrorLimit,
+      window: config?.window ?? AGENT_DEFAULTS.loopWindow,
+      sessionToolErrorLimit: config?.sessionToolErrorLimit ?? AGENT_DEFAULTS.loopSessionToolErrorLimit,
+      consecutiveFailedTurnLimit: config?.consecutiveFailedTurnLimit ?? AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit,
+      fileReadLimit: config?.fileReadLimit ?? AGENT_DEFAULTS.loopFileReadLimit
+    };
+  }
+
+  /** Create a LoopDetector from a ResolvedAgentLoopConfig */
+  static fromResolved(resolved) {
+    return new LoopDetector({
+      identicalCallLimit: resolved.loopIdenticalCallLimit,
+      consecutiveErrorLimit: resolved.loopConsecutiveErrorLimit,
+      turnErrorLimit: resolved.loopTurnErrorLimit,
+      window: resolved.loopWindow,
+      sessionToolErrorLimit: resolved.loopSessionToolErrorLimit,
+      consecutiveFailedTurnLimit: resolved.loopConsecutiveFailedTurnLimit,
+      fileReadLimit: resolved.loopFileReadLimit
+    });
+  }
+  errorKey(name, input) {
+    if (input && typeof input.action === "string") return `${name}:${input.action}`;
+    return name;
+  }
+  recordCall(name, input) {
+    const inputHash = djb2Hash(JSON.stringify({
+      name,
+      ...input
+    }));
+    const eKey = this.errorKey(name, input);
+    if (this.failedStrategies.has(inputHash)) {
+      return {
+        blocked: true,
+        reason: `Blocked: this exact "${name}" call failed in a previous turn. Try a fundamentally different approach.`
+      };
+    }
+    const sessionErrorCount = this.sessionErrors.get(eKey) || 0;
+    if (sessionErrorCount >= this.config.sessionToolErrorLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" (action: ${input.action || "default"}) has failed ${sessionErrorCount} times this session. Stop using this tool and try a different approach.`
+      };
+    }
+    if (this.turnErrors >= this.config.turnErrorLimit) {
+      return {
+        blocked: true,
+        reason: `${this.turnErrors} errors this turn. Stop and re-assess your approach.`
+      };
+    }
+    const errorCount = this.consecutiveErrors.get(eKey) || 0;
+    if (errorCount >= this.config.consecutiveErrorLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" (action: ${input.action || "default"}) blocked: failed ${errorCount} times consecutively. Try a different approach or action.`
+      };
+    }
+    const windowSlice = this.history.slice(-this.config.window);
+    const identicalCount = windowSlice.filter(h => h.inputHash === inputHash).length;
+    if (identicalCount >= this.config.identicalCallLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" blocked: identical call made ${identicalCount} times. Try different parameters.`
+      };
+    }
+    this.history.push({
+      name,
+      inputHash
+    });
+    if (this.history.length > this.config.window * 2) {
+      this.history = this.history.slice(-this.config.window);
+    }
+    return {
+      blocked: false
+    };
+  }
+  trackRead(path) {
+    const readCount = (this.fileReadCounts.get(path) || 0) + 1;
+    this.fileReadCounts.set(path, readCount);
+    if (readCount > this.config.fileReadLimit) {
+      return {
+        blocked: true,
+        reason: `File "${path}" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`
+      };
+    }
+    return {
+      blocked: false
+    };
+  }
+  recordResult(name, success, input, transient) {
+    const eKey = this.errorKey(name, input);
+    if (success) {
+      this.consecutiveErrors.delete(eKey);
+    } else {
+      const current = this.consecutiveErrors.get(eKey) || 0;
+      this.consecutiveErrors.set(eKey, current + 1);
+      this.turnErrors++;
+      this.turnHadErrors = true;
+      const sessionCount = this.sessionErrors.get(eKey) || 0;
+      this.sessionErrors.set(eKey, sessionCount + 1);
+      this.totalSessionErrors++;
+      if (input && !transient) {
+        const inputHash = djb2Hash(JSON.stringify({
+          name,
+          ...input
+        }));
+        this.failedStrategies.add(inputHash);
+        if (this.failedStrategies.size > 200) {
+          const arr = Array.from(this.failedStrategies);
+          this.failedStrategies = new Set(arr.slice(-100));
+        }
+      }
+    }
+  }
+  endTurn() {
+    if (this.turnHadErrors) {
+      this.consecutiveFailedTurns++;
+    } else {
+      this.consecutiveFailedTurns = 0;
+      this.failedStrategies.clear();
+      if (this.sessionErrors.size > 0) {
+        for (const [key, count] of this.sessionErrors) {
+          const decayed = Math.floor(count / 2);
+          if (decayed <= 0) {
+            this.sessionErrors.delete(key);
+          } else {
+            this.sessionErrors.set(key, decayed);
+          }
+        }
+      }
+    }
+    if (this.consecutiveFailedTurns < this.config.consecutiveFailedTurnLimit) {
+      for (const [key, count] of this.consecutiveErrors) {
+        if (count >= this.config.consecutiveErrorLimit) {
+          this.consecutiveErrors.set(key, this.config.consecutiveErrorLimit - 1);
+        }
+      }
+    }
+    this.turnErrors = 0;
+    this.turnHadErrors = false;
+    if (this.consecutiveFailedTurns >= this.config.consecutiveFailedTurnLimit) {
+      return {
+        shouldBail: true,
+        message: `You have had errors in ${this.consecutiveFailedTurns} consecutive turns (${this.totalSessionErrors} total errors). Your approach is not working. STOP and explain to the user what's failing.`
+      };
+    }
+    return {
+      shouldBail: false
+    };
+  }
+  resetTurn() {
+    this.turnErrors = 0;
+    this.turnHadErrors = false;
+  }
+  reset() {
+    this.resetTurn();
+    this.history = [];
+    this.consecutiveErrors.clear();
+    this.sessionErrors.clear();
+    this.failedStrategies.clear();
+    this.fileReadCounts.clear();
+    this.consecutiveFailedTurns = 0;
+    this.totalSessionErrors = 0;
+  }
+  getSessionStats() {
+    return {
+      totalErrors: this.totalSessionErrors,
+      failedStrategies: this.failedStrategies.size,
+      consecutiveFailedTurns: this.consecutiveFailedTurns
+    };
+  }
+}
+//# sourceMappingURL=agent-core-loop.js.map

package/dist/shared/agent-core-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-core-loop.js","names":["AGENT_DEFAULTS","resolveToolChoice","opts","toolChoice","undefined","recentToolUses","length","last3","slice","last6","isRepeatingPair","turnCount","userMessage","availableToolNames","msgLower","toLowerCase","toolName","includes","type","name","djb2Hash","str","hash","i","charCodeAt","toString","LoopDetector","history","consecutiveErrors","Map","turnErrors","turnHadErrors","sessionErrors","failedStrategies","Set","consecutiveFailedTurns","totalSessionErrors","fileReadCounts","constructor","config","identicalCallLimit","loopIdenticalCallLimit","consecutiveErrorLimit","loopConsecutiveErrorLimit","turnErrorLimit","loopTurnErrorLimit","window","loopWindow","sessionToolErrorLimit","loopSessionToolErrorLimit","consecutiveFailedTurnLimit","loopConsecutiveFailedTurnLimit","fileReadLimit","loopFileReadLimit","fromResolved","resolved","errorKey","input","action","recordCall","inputHash","JSON","stringify","eKey","has","blocked","reason","sessionErrorCount","get","errorCount","windowSlice","identicalCount","filter","h","push","trackRead","path","readCount","set","recordResult","success","transient","delete","current","sessionCount","add","size","arr","Array","from","endTurn","clear","key","count","decayed","Math","floor","shouldBail","message","resetTurn","reset","getSessionStats","totalErrors"],"sources":["../../src/shared/agent-core-loop.ts"],"sourcesContent":["/**\n * Agent Core Loop — LoopDetector, ToolChoice resolution\n * Extracted from agent-core.ts for modularity.\n * resolveAgentLoopConfig moved to agent-core-config.ts to keep this under 300 lines.\n */\n\nimport {\n  AGENT_DEFAULTS,\n  type LoopCheckResult,\n  type BailCheckResult,\n  type ToolChoice,\n  type LoopDetectorConfig,\n  type ResolvedAgentLoopConfig,\n} from \"./agent-core-types.js\";\n\n// ============================================================================\n// TOOL CHOICE RESOLUTION\n// ============================================================================\n\n/**\n * Resolve the effective tool_choice for a given turn.\n *\n * Priority:\n * 1. Explicit override from caller (toolChoice option)\n * 2. Loop detection: if last 3 turns all used the same tool, force \"none\"\n * 3. Keyword detection: if user message mentions a tool name, force that tool\n * 4. Default: \"auto\"\n */\nexport function resolveToolChoice(\n  opts: {\n    toolChoice?: ToolChoice;\n    turnCount: number;\n    recentToolUses: string[];\n    availableToolNames: string[];\n    userMessage: string;\n  },\n): ToolChoice {\n  if (opts.toolChoice !== undefined) return opts.toolChoice;\n\n  if (opts.recentToolUses.length >= 3) {\n    const last3 = opts.recentToolUses.slice(-3);\n    if (last3[0] === last3[1] && last3[1] === last3[2]) {\n      return \"none\";\n    }\n  }\n\n  if (opts.recentToolUses.length >= 6) {\n    const last6 = opts.recentToolUses.slice(-6);\n    const isRepeatingPair =\n      last6[2] === last6[0] && last6[3] === last6[1] &&\n      last6[4] === last6[0] && last6[5] === last6[1];\n    if (isRepeatingPair) return \"none\";\n  }\n\n  if (opts.turnCount === 1 && opts.userMessage && opts.availableToolNames.length > 0) {\n    const msgLower = opts.userMessage.toLowerCase();\n    for (const toolName of opts.availableToolNames) {\n      if (toolName.length >= 4 && msgLower.includes(toolName.toLowerCase())) {\n        return { type: \"tool\", name: toolName };\n      }\n    }\n  }\n\n  return \"auto\";\n}\n\n// ============================================================================\n// LOOP DETECTION\n// ============================================================================\n\n/** djb2 string hash — fast, deterministic, no dependencies */\nexport function djb2Hash(str: string): string {\n  let hash = 5381;\n  for (let i = 0; i < str.length; i++) {\n    hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;\n  }\n  return hash.toString(36);\n}\n\nexport class LoopDetector {\n  private history: { name: string; inputHash: string }[] = [];\n  private consecutiveErrors = new Map<string, number>();\n  private turnErrors = 0;\n  private turnHadErrors = false;\n\n  private sessionErrors = new Map<string, number>();\n  private failedStrategies = new Set<string>();\n  private consecutiveFailedTurns = 0;\n  private totalSessionErrors = 0;\n\n  /** Tracks how many times the same file path has been read this session */\n  private fileReadCounts = new Map<string, number>();\n\n  /** Resolved config — accepts DB overrides, falls back to AGENT_DEFAULTS */\n  readonly config: LoopDetectorConfig;\n\n  constructor(config?: Partial<LoopDetectorConfig>) {\n    this.config = {\n      identicalCallLimit: config?.identicalCallLimit ?? AGENT_DEFAULTS.loopIdenticalCallLimit,\n      consecutiveErrorLimit: config?.consecutiveErrorLimit ?? AGENT_DEFAULTS.loopConsecutiveErrorLimit,\n      turnErrorLimit: config?.turnErrorLimit ?? AGENT_DEFAULTS.loopTurnErrorLimit,\n      window: config?.window ?? AGENT_DEFAULTS.loopWindow,\n      sessionToolErrorLimit: config?.sessionToolErrorLimit ?? AGENT_DEFAULTS.loopSessionToolErrorLimit,\n      consecutiveFailedTurnLimit: config?.consecutiveFailedTurnLimit ?? AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit,\n      fileReadLimit: config?.fileReadLimit ?? AGENT_DEFAULTS.loopFileReadLimit,\n    };\n  }\n\n  /** Create a LoopDetector from a ResolvedAgentLoopConfig */\n  static fromResolved(resolved: ResolvedAgentLoopConfig): LoopDetector {\n    return new LoopDetector({\n      identicalCallLimit: resolved.loopIdenticalCallLimit,\n      consecutiveErrorLimit: resolved.loopConsecutiveErrorLimit,\n      turnErrorLimit: resolved.loopTurnErrorLimit,\n      window: resolved.loopWindow,\n      sessionToolErrorLimit: resolved.loopSessionToolErrorLimit,\n      consecutiveFailedTurnLimit: resolved.loopConsecutiveFailedTurnLimit,\n      fileReadLimit: resolved.loopFileReadLimit,\n    });\n  }\n\n  private errorKey(name: string, input?: Record<string, unknown>): string {\n    if (input && typeof input.action === \"string\") return `${name}:${input.action}`;\n    return name;\n  }\n\n  recordCall(name: string, input: Record<string, unknown>): LoopCheckResult {\n    const inputHash = djb2Hash(JSON.stringify({ name, ...input }));\n    const eKey = this.errorKey(name, input);\n\n    if (this.failedStrategies.has(inputHash)) {\n      return {\n        blocked: true,\n        reason: `Blocked: this exact \"${name}\" call failed in a previous turn. Try a fundamentally different approach.`,\n      };\n    }\n\n    const sessionErrorCount = this.sessionErrors.get(eKey) || 0;\n    if (sessionErrorCount >= this.config.sessionToolErrorLimit) {\n      return {\n        blocked: true,\n        reason: `Tool \"${name}\" (action: ${input.action || \"default\"}) has failed ${sessionErrorCount} times this session. Stop using this tool and try a different approach.`,\n      };\n    }\n\n    if (this.turnErrors >= this.config.turnErrorLimit) {\n      return {\n        blocked: true,\n        reason: `${this.turnErrors} errors this turn. Stop and re-assess your approach.`,\n      };\n    }\n\n    const errorCount = this.consecutiveErrors.get(eKey) || 0;\n    if (errorCount >= this.config.consecutiveErrorLimit) {\n      return {\n        blocked: true,\n        reason: `Tool \"${name}\" (action: ${input.action || \"default\"}) blocked: failed ${errorCount} times consecutively. Try a different approach or action.`,\n      };\n    }\n\n    const windowSlice = this.history.slice(-this.config.window);\n    const identicalCount = windowSlice.filter((h) => h.inputHash === inputHash).length;\n    if (identicalCount >= this.config.identicalCallLimit) {\n      return {\n        blocked: true,\n        reason: `Tool \"${name}\" blocked: identical call made ${identicalCount} times. Try different parameters.`,\n      };\n    }\n\n    this.history.push({ name, inputHash });\n    if (this.history.length > this.config.window * 2) {\n      this.history = this.history.slice(-this.config.window);\n    }\n\n    return { blocked: false };\n  }\n\n  trackRead(path: string): LoopCheckResult {\n    const readCount = (this.fileReadCounts.get(path) || 0) + 1;\n    this.fileReadCounts.set(path, readCount);\n    if (readCount > this.config.fileReadLimit) {\n      return {\n        blocked: true,\n        reason: `File \"${path}\" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`,\n      };\n    }\n    return { blocked: false };\n  }\n\n  recordResult(name: string, success: boolean, input?: Record<string, unknown>, transient?: boolean): void {\n    const eKey = this.errorKey(name, input);\n    if (success) {\n      this.consecutiveErrors.delete(eKey);\n    } else {\n      const current = this.consecutiveErrors.get(eKey) || 0;\n      this.consecutiveErrors.set(eKey, current + 1);\n      this.turnErrors++;\n      this.turnHadErrors = true;\n\n      const sessionCount = this.sessionErrors.get(eKey) || 0;\n      this.sessionErrors.set(eKey, sessionCount + 1);\n      this.totalSessionErrors++;\n\n      if (input && !transient) {\n        const inputHash = djb2Hash(JSON.stringify({ name, ...input }));\n        this.failedStrategies.add(inputHash);\n        if (this.failedStrategies.size > 200) {\n          const arr = Array.from(this.failedStrategies);\n          this.failedStrategies = new Set(arr.slice(-100));\n        }\n      }\n    }\n  }\n\n  endTurn(): BailCheckResult {\n    if (this.turnHadErrors) {\n      this.consecutiveFailedTurns++;\n    } else {\n      this.consecutiveFailedTurns = 0;\n      this.failedStrategies.clear();\n      if (this.sessionErrors.size > 0) {\n        for (const [key, count] of this.sessionErrors) {\n          const decayed = Math.floor(count / 2);\n          if (decayed <= 0) {\n            this.sessionErrors.delete(key);\n          } else {\n            this.sessionErrors.set(key, decayed);\n          }\n        }\n      }\n    }\n\n    if (this.consecutiveFailedTurns < this.config.consecutiveFailedTurnLimit) {\n      for (const [key, count] of this.consecutiveErrors) {\n        if (count >= this.config.consecutiveErrorLimit) {\n          this.consecutiveErrors.set(key, this.config.consecutiveErrorLimit - 1);\n        }\n      }\n    }\n\n    this.turnErrors = 0;\n    this.turnHadErrors = false;\n\n    if (this.consecutiveFailedTurns >= this.config.consecutiveFailedTurnLimit) {\n      return {\n        shouldBail: true,\n        message: `You have had errors in ${this.consecutiveFailedTurns} consecutive turns (${this.totalSessionErrors} total errors). Your approach is not working. STOP and explain to the user what's failing.`,\n      };\n    }\n\n    return { shouldBail: false };\n  }\n\n  resetTurn(): void {\n    this.turnErrors = 0;\n    this.turnHadErrors = false;\n  }\n\n  reset(): void {\n    this.resetTurn();\n    this.history = [];\n    this.consecutiveErrors.clear();\n    this.sessionErrors.clear();\n    this.failedStrategies.clear();\n    this.fileReadCounts.clear();\n    this.consecutiveFailedTurns = 0;\n    this.totalSessionErrors = 0;\n  }\n\n  getSessionStats(): { totalErrors: number; failedStrategies: number; consecutiveFailedTurns: number } {\n    return {\n      totalErrors: this.totalSessionErrors,\n      failedStrategies: this.failedStrategies.size,\n      consecutiveFailedTurns: this.consecutiveFailedTurns,\n    };\n  }\n}\n"],"mappings":"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","ignoreList":[]}