fix: apply EXPLORATION_TOOLS 5x limit to success path

The previous fix (fa4808b) only exempted exploration tools from coarse
fingerprint tracking in the ERROR path. However, most read/grep calls
succeed, and the success path had no exploration exemption.

Root cause: Cross-turn accumulation. Reading the same file across many
conversation turns (legitimate re-verification) accumulated counts,
triggering the guard at 9 reads when limit was 2.

Fix: Add EXPLORATION_LIMIT_MULTIPLIER (5x) for exploration tools in
the success path. Now read/grep/glob/ls/stat/semsearch get a limit of
maxRepeat * 5 = 10 by default, allowing normal exploratory patterns.

Includes reproduction test confirming the fix works (9 historical reads
of same file no longer triggers guard).

Closes #33

Author: Nomadcxx

src/provider/tool-loop-guard.ts

@@ -75,6 +75,7 @@ export function parseToolLoopMaxRepeat(
 // to allow legitimate exploration across different files/targets while still
 // catching spray-and-pray patterns.
 const COARSE_LIMIT_MULTIPLIER = 3;
+const EXPLORATION_LIMIT_MULTIPLIER = 5;
 
 export function createToolLoopGuard(
   messages: Array<unknown>,
@@ -113,6 +114,16 @@ export function createToolLoopGuard(
         const repeatCount = (counts.get(successFingerprint) ?? 0) + 1;
         counts.set(successFingerprint, repeatCount);
 
+        // Exploration tools (read, grep, glob, etc.) get a higher limit because
+        // re-reading the same file across turns is legitimate behavior (verifying
+        // edits, checking state, etc.). Use 5x multiplier for these tools.
+        const isExplorationTool = EXPLORATION_TOOLS.has(
+          toolCall.function.name.toLowerCase(),
+        );
+        const effectiveMaxRepeat = isExplorationTool
+          ? maxRepeat * EXPLORATION_LIMIT_MULTIPLIER
+          : maxRepeat;
+
         // Some tools (notably edit/write) can get stuck in "successful" loops where
         // the model keeps re-issuing the same operation with slightly different
         // content (e.g. trailing newline differences). Track a coarse signature for
@@ -129,14 +140,14 @@ export function createToolLoopGuard(
           coarseCounts.set(coarseSuccessFingerprint, coarseRepeatCount);
         }
         const coarseTriggered = coarseSuccessFingerprint
-          ? coarseRepeatCount > maxRepeat
+          ? coarseRepeatCount > effectiveMaxRepeat
           : false;
         return {
           fingerprint: coarseTriggered ? coarseSuccessFingerprint! : successFingerprint,
           repeatCount: coarseTriggered ? coarseRepeatCount : repeatCount,
-          maxRepeat,
+          maxRepeat: effectiveMaxRepeat,
           errorClass,
-          triggered: repeatCount > maxRepeat || coarseTriggered,
+          triggered: repeatCount > effectiveMaxRepeat || coarseTriggered,
           tracked: true,
         };
       }

tests/unit/provider-tool-loop-guard.test.ts

@@ -90,12 +90,13 @@ describe("tool loop guard", () => {
       2,
     );
 
+    // Use 'edit' instead of 'read' - exploration tools have 5x limit multiplier
     const call = {
       id: "c1",
       type: "function",
       function: {
-        name: "read",
-        arguments: JSON.stringify({ path: "foo.txt" }),
+        name: "edit",
+        arguments: JSON.stringify({ path: "foo.txt", content: "bar" }),
       },
     } as const;
 
@@ -576,3 +577,67 @@ describe("tool loop guard", () => {
     expect(readDecision.triggered).toBe(true);
   });
 });
+
+  // Reproduction test for issue #33: cross-turn accumulation
+  it("ISSUE_33: should not trigger on exploration tool reads across turns", () => {
+    // Simulate: user asks agent to read file A in turn 1, turn 3, turn 5, turn 7, turn 9
+    // This is legitimate behavior - re-reading a file to verify changes is normal
+    const history = [];
+    
+    // Build 8 historical turns where agent read the same file (with success)
+    for (let turn = 1; turn <= 8; turn++) {
+      history.push({
+        role: "assistant",
+        content: null,
+        tool_calls: [
+          {
+            id: `read-turn-${turn}`,
+            type: "function",
+            function: {
+              name: "read",
+              arguments: JSON.stringify({ path: "src/important-file.ts" }),
+            },
+          },
+        ],
+      });
+      history.push({
+        role: "tool",
+        tool_call_id: `read-turn-${turn}`,
+        content: "export function foo() { return 42; }",
+      });
+      // User message between turns (simulating conversation flow)
+      if (turn < 8) {
+        history.push({
+          role: "user", 
+          content: `Turn ${turn + 1}: Please check the file again`,
+        });
+      }
+    }
+
+    const guard = createToolLoopGuard(history, 2);
+
+    // Now agent reads the same file again in current turn (turn 9)
+    const decision = guard.evaluate({
+      id: "read-turn-9",
+      type: "function",
+      function: {
+        name: "read",
+        arguments: JSON.stringify({ path: "src/important-file.ts" }),
+      },
+    });
+
+    // CURRENT BEHAVIOR (BUG): This triggers because count = 9 > limit 2
+    // EXPECTED BEHAVIOR: Should NOT trigger - reading same file across turns is legitimate
+    console.log("Issue #33 reproduction:", {
+      triggered: decision.triggered,
+      repeatCount: decision.repeatCount,
+      maxRepeat: decision.maxRepeat,
+      fingerprint: decision.fingerprint,
+    });
+    
+    // This test documents current (buggy) behavior
+    // When fixed, change expect to: expect(decision.triggered).toBe(false);
+    expect(decision.triggered).toBe(false); // FIXED: exploration tools get 5x limit
+    expect(decision.repeatCount).toBe(9);  // 8 historical + 1 current
+    expect(decision.maxRepeat).toBe(10);   // 2 * 5 (EXPLORATION_LIMIT_MULTIPLIER)
+  });