fix(core): halt turns on repeated identical tool errors

packages/cli/src/nonInteractiveCli.test.ts

@@ -2527,6 +2527,52 @@ describe('runNonInteractive', () => {
     );
   });
 
+  it('shows the always-on hint (not the skipLoopDetection escape) for a repeated-tool-error halt', async () => {
+    setupMetricsMock();
+    const toolCallEvent: ServerLlmStreamEvent = {
+      type: LlmEventType.ToolCallRequest,
+      value: {
+        callId: 'tool-1',
+        name: 'run_shell_command',
+        args: { command: 'git remote show origin' },
+        isClientInitiated: false,
+        prompt_id: 'prompt-id-repeated-tool-error',
+      },
+    };
+    const events: ServerLlmStreamEvent[] = [
+      toolCallEvent,
+      {
+        type: LlmEventType.LoopDetected,
+        value: { loopType: LoopType.REPEATED_TOOL_ERROR },
+      },
+    ];
+    mockLlmClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+
+    const exitCode = await runNonInteractive(
+      mockConfig,
+      mockSettings,
+      'Repeat a tool',
+      'prompt-id-repeated-tool-error',
+    );
+
+    expect(exitCode).toBe(1);
+    // The error-repetition guard is always-on and never consults
+    // skipLoopDetection (neither runtime wiring gates it), so the headless
+    // message must not suggest the no-op setting as an escape hatch.
+    expect(processStderrSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'always-on guard and cannot be disabled via `model.skipLoopDetection`',
+      ),
+    );
+    expect(processStderrSpy).not.toHaveBeenCalledWith(
+      expect.stringContaining(
+        'Set the `model.skipLoopDetection` setting to true',
+      ),
+    );
+  });
+
   it('shows the skipLoopDetection escape hint for a heuristic loop type', async () => {
     setupMetricsMock();
     const toolCallEvent: ServerLlmStreamEvent = {

packages/cli/src/nonInteractiveCli.ts

@@ -198,6 +198,8 @@ const LOOP_TYPE_LABELS: Record<LoopType, string> = {
     'the model repeatedly sent invalid tool parameters without correcting them',
   [LoopType.REPEATED_TOOL_EXECUTION_FAILURE]:
     'the same tool execution failure continued after a corrective reminder',
+  [LoopType.REPEATED_TOOL_ERROR]:
+    'the model kept receiving the same tool error without making progress',
 };
 
 function formatLoopDetectedMessage(loopType: LoopType | undefined): string {
@@ -212,7 +214,8 @@ function formatLoopDetectedMessage(loopType: LoopType | undefined): string {
     loopType === LoopType.SHELL_COMMAND_STAGNATION ||
     loopType === LoopType.GLOBAL_TOOL_CALL_DUPLICATE ||
     loopType === LoopType.INVALID_TOOL_PARAMS_STAGNATION ||
-    loopType === LoopType.REPEATED_TOOL_EXECUTION_FAILURE;
+    loopType === LoopType.REPEATED_TOOL_EXECUTION_FAILURE ||
+    loopType === LoopType.REPEATED_TOOL_ERROR;
   const hint =
     loopType === LoopType.TURN_TOOL_CALL_CAP
       ? ' A per-turn tool-call cap was reached. The default is adaptive (allows up to 1000 diverse calls, halting only on repeated calls); an explicitly set `model.maxToolCallsPerTurn` is a hard cap. If the model was repeating the same call, investigate the repetition; otherwise unset the value to use the adaptive default, or raise it (set 0 to disable).'

packages/core/src/agents/runtime/agent-core.ts

@@ -1241,6 +1241,19 @@ export class AgentCore {
               break;
             }
           }
+          if (terminateMode !== AgentTerminateMode.LOOP_DETECTED) {
+            // Error-repetition guard (issue #10887): one batch-level
+            // recording per round — the sibling calls of this round are ONE
+            // round of evidence, not sequential retries, so a single
+            // denied/cancelled batch cannot trip the guard before the model
+            // has seen any of the errors.
+            const roundResultParts = toolCallResult.results.flatMap(
+              (toolResult) => toolResult.responseParts,
+            );
+            if (loopDetector.recordToolErrorBatch(roundResultParts)) {
+              terminateMode = AgentTerminateMode.LOOP_DETECTED;
+            }
+          }
           if (terminateMode === AgentTerminateMode.LOOP_DETECTED) {
             break;
           }

packages/core/src/core/client.test.ts

@@ -8478,6 +8478,95 @@ hello
       ).toBe('consecutive_identical_tool_calls');
     });
 
+    // Drives sendMessageStream with ToolResult messages carrying failed tool
+    // results, exercising the runtime wiring of the error-repetition guard
+    // (issue #10887): every ToolResult round must reach
+    // loopDetector.recordToolErrorBatch, and a detection must halt the
+    // turn with a LoopDetected event. The tool varies its args on every
+    // round — the reported dead-end shape — so no argument-based repetition
+    // signal can accumulate; only the batch feed sees the repeated error.
+    // Reverting the recordToolErrorBatch wiring in client.ts leaves the turn
+    // running and fails the halt test below.
+    async function runFailingToolTurns(
+      errorFor: (round: number) => string,
+      maxRounds = 5,
+    ) {
+      const promptId = 'prompt-repeated-tool-error';
+      const allEvents: Array<{ type: string; value?: unknown }> = [];
+      for (let round = 0; round <= maxRounds; round++) {
+        mockTurnRunFn.mockReturnValueOnce(
+          (async function* () {
+            yield {
+              type: LlmEventType.ToolCallRequest,
+              value: {
+                callId: `fail-${round}`,
+                name: 'run_shell_command',
+                args: { command: `attempt-${round}` },
+                isClientInitiated: false,
+                prompt_id: promptId,
+              },
+            };
+          })(),
+        );
+        const contents =
+          round === 0
+            ? [{ text: 'do the work' }]
+            : [
+                {
+                  functionResponse: {
+                    id: `fail-${round - 1}`,
+                    name: 'run_shell_command',
+                    response: { error: errorFor(round - 1) },
+                  },
+                },
+              ];
+        const events = await fromAsync(
+          client.sendMessageStream(
+            contents as never,
+            new AbortController().signal,
+            promptId,
+            {
+              type:
+                round === 0
+                  ? SendMessageType.UserQuery
+                  : SendMessageType.ToolResult,
+            },
+          ),
+        );
+        allEvents.push(...(events as Array<{ type: string; value?: unknown }>));
+        if (
+          allEvents.some((e) => e.type === LlmEventType.LoopDetected) ||
+          !events.some((e) => e.type === LlmEventType.ToolCallRequest)
+        ) {
+          return allEvents;
+        }
+      }
+      return allEvents;
+    }
+
+    it('halts the interactive turn when ToolResult rounds keep returning the same error (#10887)', async () => {
+      const events = await runFailingToolTurns(
+        () =>
+          'fatal: not a git repository (or any of the parent directories): .git',
+      );
+      const loopEvent = events.find(
+        (e) => e.type === LlmEventType.LoopDetected,
+      );
+      expect(loopEvent).toBeDefined();
+      expect(
+        (loopEvent?.value as { loopType?: string } | undefined)?.loopType,
+      ).toBe('repeated_tool_error');
+    });
+
+    it('keeps the interactive turn alive while ToolResult errors keep changing (#10887)', async () => {
+      const events = await runFailingToolTurns(
+        (round) => `fatal: attempt ${round} failed in a new way`,
+      );
+      expect(events.some((e) => e.type === LlmEventType.LoopDetected)).toBe(
+        false,
+      );
+    });
+
     it('should halt via the always-on turn cap before the skipLoopDetection gate', async () => {
       let abortHandlerInvoked = false;
       mockMemoryManager.recall.mockImplementation((_root, _query, opts) => {

packages/core/src/core/client.ts

@@ -3940,6 +3940,8 @@ export class LlmClient {
         // loop (issue #9450). A detection here (the result-aware global
         // duplicate count) halts the turn exactly like the event-loop
         // guards below.
+        let loopHalt = false;
+        const toolResultParts: Part[] = [];
         for (const part of requestToSend) {
           if (
             typeof part !== 'object' ||
@@ -3950,29 +3952,42 @@ export class LlmClient {
           }
           const functionResponseId = (part as Part).functionResponse?.id;
           if (!functionResponseId) continue;
+          toolResultParts.push(part as Part);
           if (
             this.loopDetector.recordToolResultByCallId(functionResponseId, [
               part as Part,
             ])
           ) {
-            for (const goalEvent of await finalizeInterruptedGoalTurn(
-              undefined,
-              'loop detected',
-            )) {
-              yield goalEvent;
-            }
-            const loopType = this.loopDetector.getLastLoopType();
-            yield {
-              type: LlmEventType.LoopDetected,
-              ...(loopType && { value: { loopType } }),
-            };
-            await arenaAgentClient?.reportError('Loop detected');
-            this.lastApiCompletionTimestamp = Date.now();
-            endCurrentInteraction('error', 'loop detected', 'loop_detected');
-            this.cancelPendingMemoryPrefetch('no_safe_delivery_point');
-            this.fireLoopDetectedStopFailure(loopType);
-            return turn;
+            loopHalt = true;
+            break;
+          }
+        }
+        // Error-repetition guard (issue #10887): one batch-level recording
+        // per ToolResult message, so the sibling calls of this round count
+        // as ONE round of evidence, not as sequential retries — a single
+        // denied/cancelled batch must not trip the guard before the model
+        // has seen any of the errors.
+        if (!loopHalt) {
+          loopHalt = this.loopDetector.recordToolErrorBatch(toolResultParts);
+        }
+        if (loopHalt) {
+          for (const goalEvent of await finalizeInterruptedGoalTurn(
+            undefined,
+            'loop detected',
+          )) {
+            yield goalEvent;
           }
+          const loopType = this.loopDetector.getLastLoopType();
+          yield {
+            type: LlmEventType.LoopDetected,
+            ...(loopType && { value: { loopType } }),
+          };
+          await arenaAgentClient?.reportError('Loop detected');
+          this.lastApiCompletionTimestamp = Date.now();
+          endCurrentInteraction('error', 'loop detected', 'loop_detected');
+          this.cancelPendingMemoryPrefetch('no_safe_delivery_point');
+          this.fireLoopDetectedStopFailure(loopType);
+          return turn;
         }
         const toolResultMemory =
           await this.consumeManagedAutoMemoryRecall('tool_result');

packages/core/src/core/coreToolScheduler.ts

@@ -1035,6 +1035,17 @@ const createErrorResponse = (
   ...(artifacts && artifacts.length > 0 ? { artifacts } : {}),
 });
 
+/**
+ * Prefix of the model-visible error payload this scheduler produces for
+ * cancelled tool calls (see createCancelledResponse and the auxiliary-cancel
+ * path in the `'cancelled'` case of `setStatusInternal`). Exported so consumers that must
+ * recognize cancellation payloads — the loop-detection error-repetition
+ * guard (services/loopDetectionService.ts) — match the producer-owned
+ * constant instead of re-declaring the literal (producer-owns-the-shape
+ * pattern, cf. ORPHAN_TOOL_USE_REPAIR_REASON in llm-chat.ts).
+ */
+export const CANCELLED_TOOL_ERROR_PREFIX = '[Operation Cancelled] Reason:';
+
 const createCancelledResponse = (
   request: ToolCallRequestInfo,
   reason: string,
@@ -1045,7 +1056,7 @@ const createCancelledResponse = (
   persistedOutputFiles?: string[],
   visionBridgeNotice?: string,
 ): CoreToolCallResponseInfo => {
-  const errorMessage = `[Operation Cancelled] Reason: ${reason}`;
+  const errorMessage = `${CANCELLED_TOOL_ERROR_PREFIX} ${reason}`;
   return {
     callId: request.callId,
     responseParts: [
@@ -1755,7 +1766,7 @@ export class CoreToolScheduler {
 
           const preservedResultDisplay =
             this.compactResultDisplayForInteractiveHistory(resultDisplay);
-          const errorMessage = `[Operation Cancelled] Reason: ${auxiliaryData}`;
+          const errorMessage = `${CANCELLED_TOOL_ERROR_PREFIX} ${auxiliaryData}`;
           const response: CoreToolCallResponseInfo = isToolCallResponseInfo(
             auxiliaryData,
           )