The maxSameCallRepeats guard counted identical (name+arguments) tool calls
across a run and tripped ErrToolLoop past the ceiling — regardless of whether
each call made progress. This killed legitimate polling of long-running
background jobs: code_exec_poll must be called with identical args (same
job_id), so a render/encode that needs more than N polls was guillotined
mid-flight even as each poll returned an advancing result (elapsed/status
moving forward).

Only count an identical call toward the trip when its RESULT is unchanged
from the previous identical call. A call whose result keeps changing is
progress and resets its count; a genuinely stuck call returning the same
output still trips. This can never trip more than before, only less, and
covers every idempotent poller with no per-tool configuration — matching the
progress-over-usage thesis behind the stall-detection work.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01HgEuVfZJN9mhRhzEsMEVog

@@ -279,1 +284,4 @@
+	// background job whose progress advances) resets the count instead of
+	// tripping the guard — a changing result is progress, not a stuck loop.
 	callCounts := make(map[string]int)
+	lastResults := make(map[string]string)

@@ -356,6 +357,37 @@ func (a *Agent) Run(ctx context.Context, input string, opts ...RunOption) (*Resu
 		a.notify(rc, step)
 		msgs = append(msgs, llm.ToolResultsMessage(results...))
 
+		// Same-call repeat guard (progress-aware). An identical (name+arguments)

@@ -359,0 +370,4 @@
+			for i, call := range resp.ToolCalls {
+				sig := call.Name + "\x00" + string(call.Arguments)
+				resKey := ""
+				if i < len(results) {

@@ -359,0 +376,4 @@
+					}
+					resKey += results[i].Content
+				}
+				if prev, seen := lastResults[sig]; seen && prev == resKey {

@@ -176,0 +178,4 @@
+// RESULT keeps changing — canonically polling a long-running background job
+// whose progress advances — do not trip the repeat guard even well past the
+// limit; but identical calls returning an unchanged result still trip it.
+func TestSameCallRepeatGuardProgressAware(t *testing.T) {