fix(agent): cut degenerate thinking-stream runs, quote litter and word loops before storage and echo

[maebahesioru]

What does this PR do?

Cuts a thinking/reasoning stream that has degenerated into a growing single-char run (「「「「「「実行」」」」」」…, run length exploding line over line) before the looped bytes reach the live display, the stored transcript, or the next request. The turn itself survives — visible content and tool calls keep streaming normally.

A second shape is covered too: quote litter — openers inserted between tokens and mostly never closed (「の「diff「全体「像), net unmatched openers climbing steadily with no long run anywhere, so the run rules never fire. Chronic in long-lived sessions (1143 rows across 4 sessions in the same corpus scan). Rule: ≥600 chars fed, ≥20 net unmatched 「, ≥1.5% of chars unmatched, and quoting-dense (≥5 openers) in at least half of the 200-char bins — fires on ~93% of the chronic rows, zero fires elsewhere (analysis sessions that quote degenerate excerpts peak at a 1.4% rate and a 0.27 dense-bin fraction, under the thresholds).

A third shape is word-level: one word (nearly always the English article) swells until it fills the channel — the move: the the the crossing: the the … — with no character run anywhere, so both rules above stay silent (a 65k-token half of pure the appears in the corpus). Rule: a word-level pass that trips when ONE word both repeats and dominates — a ≥10-run of an article/filler cue word (the/a/an/hmm) or ≥25 consecutive of any other word, at ≥30% word share over ≥50 words; the spread shape (runs of only 2-4, the article wedged between tokens) is covered by an adjacent-pair gate (≥8 adjacent pairs of a cue word, ≥40% share, ≥60 words). Calibrated on the same 149k-message corpus: fired on 286 degenerate rows across 4 chronic sessions and on zero healthy rows — explicitly audited silent on the shapes that must never trip: xx hex dumps, Down Down command runs, [False, False] arrays, code discussion around repeated variable names (pc), and HTML div listings.

This is the thinking-channel complement to the streaming repetition guards under review (#89294, #78551), not a duplicate of them:

• The existing 60-char window algorithm (the basis of feat: streaming repetition guard — detect degenerate output on the fly #89294) needs exact repeats; the growing-run shape has none — it caught 4 of 21 messages in the captured set.
• fix(agent): stop degenerate output repetition during streaming #78551's line-window / periodic-tail / entropy detector fires on 2 of 40 of the same messages (both 34k-char total runaways), and terminates the whole turn on any trip.
• This guard fires on 40/40 of them, cuts only the looped tail, and keeps the turn alive.

Why the echo matters: providers that require a reasoning_content echo on tool-call replays (DeepSeek V4 / Kimi / MiMo — _needs_thinking_reasoning_pad) replay stored reasoning into the next request. Once a session starts looping, the echoed bytes re-seed the pattern on every following turn; a captured session kept re-degenerating across turns until the stored bytes were cut. Cutting at the storage boundary is therefore part of the fix, not just a display nicety.

Related Issue

No linked issue — root-caused and reproduced from captured session data (real sessions, ~175k stored reasoning messages). Happy to file one if the project prefers issue-first for this class.

Type of Change

• 🐛 Bug fix (non-breaking change that fixes an issue)

Changes Made

• agent/repetition_guard.py — new ReasoningLoopGuard (incremental, O(chars)) + sanitize_degenerate_reasoning() + THINKING_LOOP_TRUNCATED marker. Trips on runs of 「」『』 ≥ 12, any non-formatting char run ≥ 160, the quote-litter rule, or the word-loop rules (≥10-run of a cue word / ≥25 of any word at ≥30% word dominance; adjacent-pair spread gate at ≥8 pairs / ≥40% / ≥60 words). Thresholds calibrated over the full local corpus (~175k reasoning messages): zero fires on the non-degenerate remainder; all 40 captured run-loop messages, ~93% of 1143 chronic litter rows, and 286 word-loop rows across 4 chronic sessions fire. Word runs crossing deltas stay continuous (a pending word is carried across feeds).
• agent/chat_completion_helpers.py
  • _call_chat_completions (streaming): the reasoning accumulator feeds the guard per delta; on trip it keeps the clean prefix, removes the looped tail from reasoning_parts, stops emitting further reasoning deltas and emits the marker once. The stream keeps being consumed — content/tool calls are unaffected.
  • _assistant_reasoning_text + build_assistant_message: sanitize at the extraction/storage boundary, covering non-streaming intakes and every wire that stores through these paths.
• tests/agent/test_reasoning_loop_guard.py — behavior contracts: cut-at-run-start semantics, chunked-feeding equivalence (char and word paths), healthy-shape no-fire, quote-litter cut + runway floor + analysis-quoting no-fire, word-loop cut + dominance/volume no-fire + quoting no-fire + non-cue runaway runs.

How to Test

1. Unit: scripts/run_tests.sh tests/agent/test_reasoning_loop_guard.py → 11 passed (the sibling repetition-guard files and the full suite run in CI).
2. Degenerate input: sanitize_degenerate_reasoning("手順。\n" + "「" * 30 + "実行" + "」" * 30) → "手順。" + "\n\n" + "[thinking truncated: repetition loop detected]".
3. Live: a real streaming chat completion on the patched tree is unaffected for healthy turns.

Checklist

Code

• I've read the Contributing Guide
• My commit messages follow Conventional Commits (fix(scope):, feat(scope):, etc.)
• I searched for existing PRs to make sure this isn't a duplicate (see the feat: streaming repetition guard — detect degenerate output on the fly #89294 / fix(agent): stop degenerate output repetition during streaming #78551 relationship above — this is the thinking-channel growing-run shape they don't cover)
• My PR contains only changes related to this fix/feature (no unrelated commits)
• I've run pytest tests/ -q and all tests pass
• I've added tests for my changes (required for bug fixes, strongly encouraged for features)
• I've tested on my platform: Arch-family Linux (CachyOS), kernel 7.2, Python 3.11

Documentation & Housekeeping

• I've updated relevant documentation (README, docs/, docstrings) — N/A
• I've updated cli-config.yaml.example if I added/changed config keys — N/A
• I've updated CONTRIBUTING.md or AGENTS.md if I changed architecture or workflows — N/A
• I've considered cross-platform impact (Windows, macOS) per the compatibility guide — pure-Python, no platform-specific code

[maebahesioru]

Local run note from the author (updated):

• Focused suites pass: tests/agent/test_reasoning_loop_guard.py + the two existing repetition-guard files → 11 passed.
• My earlier failure list was an environment gap, not the change: this machine's runtime venv lacked optional provider SDKs (24 of the failures were ImportError: The 'anthropic' package is required; the rest fell back to the wrong client class). After installing the CI extras set into a dedicated dev venv (uv sync --locked --extra all --extra dev --extra anthropic --extra mistral ..., same as tests.yml), all 38 previously-failing files pass: 1060 passed, 0 failed.
• A local full-suite run reached 48% (25,964 passed) before I stopped it to free the workstation. One failure appeared mid-run (tests/hermes_cli/test_cmd_update.py::TestRepairCurrentCheckoutRuntimeRepair::test_venv_repair_path_refreshes_memory_provider, a subprocess/multiprocessing error); it passes on rerun → flake, unrelated to this change.
• Leaving the complete run to CI.

[maebahesioru]

Third shape pushed: word-level loops (the the the …), commit aa5802b1.

• The pass trips when one word both repeats and dominates the message: a ≥10-run of an article/filler cue word (the/a/an/hmm) or ≥25 consecutive of any other word, at ≥30% word share over ≥50 words fed; the spread shape (runs of only 2-4, article wedged between tokens) is covered by an adjacent-pair gate (≥8 pairs of a cue word, ≥40% share, ≥60 words).
• Corpus calibration (149k stored reasoning messages): fires on 286 degenerate rows across 4 chronic sessions, zero healthy fires. Verified silent on the shapes that must never trip: xx hex dumps, Down Down Down command runs, [False, False] arrays, code discussion around a variable named pc, HTML div listings.
• Streaming continuity: a short pending word is carried across deltas, so a run crossing chunk boundaries counts as one run (test asserts chunked feed lands on the same trip offset as a single feed). Cost stays incremental.
• Tests: tests/agent/test_reasoning_loop_guard.py → 11 passed (5 new word-rule tests: cut at the onset, chunked equivalence, dominance/volume no-fire, quoting no-fire, non-cue runaway run).