fix(core): detect long verbatim repetition loops in content and reasoning streams (#9668)

* fix(core): detect long verbatim repetition loops in content and reasoning streams

The chunk-hash content loop rule only treats repeated 50-char chunks as a
loop when their occurrences cluster within 1.5 chunk lengths (75 chars), so
a verbatim-repeated unit longer than that (the ~300-char analysis block
chanted in issue #1775) never fires. Add a long-period rule: five equally
spaced occurrences of an identical chunk mark a candidate period, and the
spanned region is verified to be exactly periodic with that stride before
halting. Raise the content history window so long units stay observable.

Also route thought text into the content-repetition detectors when the
structured thought check does not fire: OpenAI-compatible providers stream
reasoning as thought parts that getResponseText filters out of Content
events, so chants in the thinking stage never reached the chunk-hash rules.

* fix(core): isolate reasoning deltas from the content channel's markdown state

Route thought-sourced text through an append-and-analyze-only entry point
instead of checkContentLoop. Reasoning text is raw chain-of-thought, never
rendered markdown: an unbalanced code fence in a thought used to flip the
shared inCodeBlock parity — which nothing clears mid-turn — silently
disabling visible-content chant detection for the rest of the turn, and
list/heading-shaped thought deltas reset the shared history, erasing
already-accumulated content evidence when a provider interleaves thought
and content parts.

* fix(core): grow the periodic-rule verified region with the repetition count

The long-period rule only inspected the last five occurrences, pinning the
verified region at 4 x stride + 50 chars: units of ~76-237 chars fell in a
gap between the clustered rule's 75-char bound and the 1000-char region
floor at any repetition count, and units of ~1 KB or more could never fit
five occurrences into the 4000-char history window at all. Extend the
candidate run backwards over the longest equally-spaced suffix of
occurrences so the verified region grows with the repetition count, and
once the history saturates accept a shorter run (>= 3 occurrences) when the
entire retained region is verified periodic back to the history start, so
earlier occurrences truncated out of the window cannot hide a chant. Also
correct the constants' comments describing the rule's domains.

* test(core): cover post-truncation chant detection after a long varied turn

Add the realistic #1775 shape that had no positive coverage: a long varied
turn filling the history window, then a ~700-char chant streamed as
misaligned deltas. Asserts detection at exactly the fifth in-window
occurrence, pinning MAX_HISTORY_LENGTH, truncateAndUpdate's index
adjustment, and the long-unit case together — a shrunken window would fire
early via the truncated-run path once the filler flushes, and a broken
index adjustment would never fire.

* fix(cli): widen chanting halt label to cover reasoning-stream repetitions

Reasoning-stream chants fire CHANTING_IDENTICAL_SENTENCES via
checkReasoningContentLoop, but getResponseText filters reasoning out of
visible output, so the headless label 'repeated the same sentence in its
output' sends users looking for a repetition that is never rendered.
Widen the label to 'output or reasoning' and add a headless-path
regression test asserting the wording.

* refactor(core): share the append/truncate/analyze tail across loop channels

checkReasoningContentLoop duplicated the streamContentHistory append,
truncateAndUpdate, analyzeContentChunksForLoop tail of checkContentLoop,
leaving the history contract in two copies that a future fix could let
drift. Extract the tail into appendToContentHistoryAndAnalyze and call
it from both entry points.

* perf(core): compare periodic regions in place instead of slicing history

isRegionPeriodicWithStride sliced up to ~4 KB of history per invocation.
Near-periodic chants fail verification repeatedly while their occurrence
runs persist, so once a run reaches length 5 the check fires on up to
every streamed character -- a probe measured ~136 MB of transient copies
over one 49k-char stream. Index the existing string directly instead;
comparison semantics are unchanged.

* fix(core): reset stream-content loop state on retry replays and model fallback

A replay (non-continuation) retry re-streams the failed attempt's
content and reasoning through the chunk detectors — the #7832
transport-replay gate admits thought-only cuts, and with deterministic
decoding the re-stream is verbatim. The Retry case in
addAndCheckHeuristicLoops cleared only the tool-call counters, so the
accumulated identical copies could fire CHANTING_IDENTICAL_SENTENCES
mid-way through an otherwise healthy attempt. Continuation retries
(isContinuation) keep the delivered text and append new output, so
their state stays. ModelFallback had no case at all: the fallback model
restarts from scratch, so mirror the replay resets for it. A genuine
chant simply re-accumulates after the restart.

* perf(core): defer content-history truncation with a hysteresis slack

Once streamContentHistory saturates, truncateAndUpdate walked the whole
contentStats map on every streamed event — Θ(window) entries in steady
state, since the stride-1 sliding window hashes every position
(~385 µs/event at window 4000 vs ~12 µs pre-saturation). With
high-frequency small reasoning deltas now routed through the path,
healthy long-thinking turns paid thousands of events of synchronous CPU.

Trim only when the length exceeds MAX_HISTORY_LENGTH by a
TRUNCATION_SLACK margin (1000 chars), slicing back to exactly
MAX_HISTORY_LENGTH, so the index-rebase walk is amortized over appended
chars. The change is behavior-neutral: the detection rules now always
operate on the logical window of the last MAX_HISTORY_LENGTH chars —
occurrences the window has passed are dropped at lookup (the exact set a
per-event trim would have removed) and the periodic rule's escape valve
verifies from the window start, i.e. exactly the content a fully-trimmed
history retains. Tests pin pre-change fire offsets across saturation and
multiple trims, plus the deferred-trim mechanics.

* feat(core): log a chanting-region excerpt on loop halt for debug

A reasoning-channel halt exits headless runs with empty stdout and only
the loop-type label on stderr; neither the LoopDetected event
(loop_type + prompt_id only), telemetry, nor any log carried an excerpt
of what repeated, leaving no way to tell a true repetition from a
detector misfire without instrumenting a repro.

Capture one period of the matched region (the span between the last two
occurrences, capped at 80 chars) when the chanting detector fires and
emit it through the config debug logger at the firing site. The
LoopDetected event contract is deliberately unchanged.

* fix(core): preserve subagent continuation retries

* test(core): cover plain subagent retry forwarding

* fix(core): omit plain retry continuation flag

Author: yiliang114

packages/cli/src/nonInteractiveCli.test.ts

@@ -2063,6 +2063,37 @@ describe('runNonInteractive', () => {
     );
   });
 
+  it('describes a chanting halt as output-or-reasoning repetition', async () => {
+    setupMetricsMock();
+    const events: ServerGeminiStreamEvent[] = [
+      {
+        type: GeminiEventType.LoopDetected,
+        value: { loopType: LoopType.CHANTING_IDENTICAL_SENTENCES },
+      },
+    ];
+    mockGeminiClient.sendMessageStream.mockReturnValue(
+      createStreamFromEvents(events),
+    );
+
+    const exitCode = await runNonInteractive(
+      mockConfig,
+      mockSettings,
+      'Chant',
+      'prompt-id-chanting-loop',
+    );
+
+    expect(exitCode).toBe(1);
+    // Reasoning-stream chants fire CHANTING_IDENTICAL_SENTENCES while
+    // getResponseText filters reasoning out of visible output, so the
+    // headless label must name both channels — a halt on an empty stdout
+    // with an "output"-only label reads as a detector misfire.
+    expect(processStderrSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        'the model repeated the same sentence in its output or reasoning',
+      ),
+    );
+  });
+
   it('shows the maxToolCallsPerTurn hint when the per-turn cap halts the run', async () => {
     setupMetricsMock();
     const events: ServerGeminiStreamEvent[] = [

packages/cli/src/nonInteractiveCli.ts

@@ -168,8 +168,12 @@ import {
 const LOOP_TYPE_LABELS: Record<LoopType, string> = {
   [LoopType.CONSECUTIVE_IDENTICAL_TOOL_CALLS]:
     'the model repeated the same tool call with identical arguments',
+  // Reasoning-stream chants fire this type too (checkReasoningContentLoop),
+  // and getResponseText filters reasoning out of visible output — the label
+  // must name both channels so a headless halt on an empty stdout is not
+  // mistaken for a detector misfire.
   [LoopType.CHANTING_IDENTICAL_SENTENCES]:
-    'the model repeated the same sentence in its output',
+    'the model repeated the same sentence in its output or reasoning',
   [LoopType.REPETITIVE_THOUGHTS]:
     'the model repeated the same reasoning thought',
   [LoopType.READ_FILE_LOOP]:

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

@@ -224,8 +224,7 @@ export function extractParentToolNames(
     new Set(
       (
         generationConfig?.tools as
-          | Array<{ functionDeclarations?: FunctionDeclaration[] }>
-          | undefined
+          Array<{ functionDeclarations?: FunctionDeclaration[] }> | undefined
       )
         ?.flatMap((tool) => tool.functionDeclarations ?? [])
         .map((declaration) => declaration.name)
@@ -970,7 +969,14 @@ export class AgentCore {
           // retry does not inherit stale data (e.g. wasOutputTruncated) from a
           // previous attempt that may have hit MAX_TOKENS.
           if (streamEvent.type === 'retry') {
-            if (checkSubagentLoop({ type: GeminiEventType.Retry })) {
+            if (
+              checkSubagentLoop({
+                type: GeminiEventType.Retry,
+                ...('isContinuation' in streamEvent
+                  ? { isContinuation: streamEvent.isContinuation }
+                  : {}),
+              })
+            ) {
               terminateMode = AgentTerminateMode.LOOP_DETECTED;
               loopDetectedInStream = true;
               break;
@@ -1514,8 +1520,7 @@ export class AgentCore {
     const registeredTool = this.runtimeContext
       .getToolRegistry()
       .getTool(toolName) as
-      | { serverName?: unknown; serverToolName?: unknown }
-      | undefined;
+      { serverName?: unknown; serverToolName?: unknown } | undefined;
     if (
       typeof registeredTool?.serverName !== 'string' ||
       typeof registeredTool.serverToolName !== 'string'

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

@@ -30,6 +30,7 @@ import {
   AuthType,
 } from '../../core/contentGenerator.js';
 import { GeminiChat } from '../../core/geminiChat.js';
+import { GeminiEventType } from '../../core/turn.js';
 import {
   getToolCallFingerprint,
   normalizeModelToolCallIds,
@@ -61,6 +62,7 @@ import { AgentTerminateMode } from './agent-types.js';
 import { WriteFileTool } from '../../tools/write-file.js';
 import { ToolNames } from '../../tools/tool-names.js';
 import { normalizeToolNameForProvider } from '../../utils/tool-name-utils.js';
+import { LoopDetectionService } from '../../services/loopDetectionService.js';
 
 vi.mock('../../core/geminiChat.js');
 vi.mock('../../core/contentGenerator.js', async (importOriginal) => {
@@ -3436,6 +3438,62 @@ describe('subagent.ts', () => {
         );
       });
 
+      it.each([
+        { retry: { type: 'retry' as const, isContinuation: true } },
+        { retry: { type: 'retry' as const } },
+      ])(
+        'forwards retry events to subagent loop detection',
+        async ({ retry }) => {
+          const loopSpy = vi
+            .spyOn(LoopDetectionService.prototype, 'addAndCheckHeuristicLoops')
+            .mockReturnValue(false);
+
+          const { config } = await createMockConfig();
+          mockSendMessageStream.mockResolvedValue(
+            (async function* () {
+              yield {
+                ...retry,
+              };
+              yield {
+                type: 'chunk',
+                value: {
+                  candidates: [
+                    {
+                      finishReason: 'STOP',
+                      content: { parts: [{ text: 'done' }] },
+                    },
+                  ],
+                },
+              };
+            })(),
+          );
+
+          const scope = await AgentHeadless.create(
+            'test-agent',
+            config,
+            promptConfig,
+            defaultModelConfig,
+            defaultRunConfig,
+            { tools: [] },
+            new AgentEventEmitter(),
+          );
+
+          await scope.execute(new ContextState());
+
+          const retryArg = loopSpy.mock.calls.find(
+            ([event]) => event.type === GeminiEventType.Retry,
+          )?.[0] as { type: GeminiEventType; isContinuation?: boolean };
+          expect(retryArg).toEqual(
+            expect.objectContaining({ type: GeminiEventType.Retry }),
+          );
+          if ('isContinuation' in retry) {
+            expect(retryArg.isContinuation).toBe(true);
+          } else {
+            expect(retryArg).not.toHaveProperty('isContinuation');
+          }
+        },
+      );
+
       it('keeps automatic max token escalation warm for the next agent round', async () => {
         const writeFileToolDef: FunctionDeclaration = {
           name: WriteFileTool.Name,