Consolidate stall-watchdog's repetition detector into subagent/repetition.ts

stall-watchdog.ts carried its own char-level tail-repetition detector
(constants + a thin wrapper over detectSequencePeriod), duplicating a
detector that already lived in subagent/repetition.ts under a different
name and shape. Moved detectCharRepetition (with its constants and
rationale comments) into subagent/repetition.ts; stall-watchdog.ts now
re-exports it as detectRepetition/RepetitionCheck for its existing callers.

No threshold values changed. The two detectors solve the same "is the tail
looping" question with genuinely different algorithms (KMP + normalization
for streamed model text vs. a plain per-char search with a distinct-chars
floor for the TUI's live buffer) so they were kept as separate functions
rather than merged into one, per CL-6939 / CL-6790.

Author: TheGreatAxios

src/subagent/repetition.ts

@@ -6,8 +6,17 @@
  * invisible to them. This module watches the accumulated text of the current
  * inference cycle and flags a trailing window that repeats verbatim past a
  * threshold, so the run loop can abort the cycle instead of streaming forever.
+ *
+ * Also home to the TUI stall-watchdog's character-level tail-repetition
+ * guard (`detectCharRepetition`) — a separate, simpler check consolidated
+ * here from tui/stall-watchdog.ts so the two repetition detectors live in one
+ * module instead of two. It solves the same "is the tail looping" question
+ * for a different consumer with different constants; see its own doc comment
+ * for why it is not merged into `detectRepetition` above.
  */
 
+import { detectSequencePeriod, type SequencePeriodCheck } from "../util/period-detection.js";
+
 /** Tunable thresholds for the trailing-window repetition check. */
 export interface RepetitionConfig {
   /** Smallest normalized window (chars) considered a loop unit. */
@@ -245,3 +254,72 @@ export function trackContentlessGrowth(
     hit: visibleChars < config.minVisibleChars,
   };
 }
+
+// The captured incident looped two sentences with no line break between them
+// ("...ranked findings.Confirming callId emission...") — degeneration is a
+// character-level loop, not a line-level one. Splitting on "\n" misses it
+// entirely, so the tail is treated as a plain string and checked for the
+// smallest period it exactly repeats: the shortest span p such that the last
+// several hundred characters equal p repeated.
+//
+// A period below this is more likely a short structural tic (indentation, a
+// repeated bullet or table-cell divider) than a looping phrase. Live loops
+// repeat units as short as 10 chars ("Groaning. " emitted ~1,363 times), so
+// the floor sits at 8 — short structural tics that survive it (a "- item\n"
+// bullet is 7 chars) fall below, and the ones at or above it are filtered by
+// the distinct-chars floor and the raised repeat bar instead. Still well
+// under the ~140-char period of the captured incident's two-sentence cycle.
+const CHAR_REPETITION_MIN_PERIOD = 8;
+// How many exact repeats of the period are required before it counts as a
+// loop rather than a coincidence. Raised 3x in step with the 3x-lower period
+// floor so the minimum exactly-periodic span stays at 192 chars (was 24*8,
+// now 8*24). Verified against real non-degenerate repetition: a 6-row
+// markdown table separator (period ~51 chars, 6 exact repeats) and 3
+// identical code lines (period ~60 chars, 3 exact repeats) both land far
+// under this bar and are not flagged; a genuine degenerate loop repeats
+// hundreds of times, so it still clears the bar long before the stream ends.
+const CHAR_REPETITION_MIN_REPEATS = 24;
+// Hard ceiling on the period search regardless of buffer size, purely to cap
+// worst-case work per check — token-level degeneration loops on a phrase or
+// two, never on multi-paragraph spans.
+const CHAR_REPETITION_MAX_PERIOD_CAP = 2_000;
+// A monochrome run ("x".repeat(500), a "----" rule, a wall of spaces) is
+// trivially periodic at *every* period, which would otherwise make it the
+// single easiest thing to false-trigger on — verified by execution against
+// `thinking-reveal.test.ts`'s burst-of-"x" fixture, which tripped the guard
+// before this floor existed. Requiring the repeating unit itself to contain
+// this many distinct characters keeps single-character and low-variety runs
+// out without weakening the sentence-level case: the captured incident's
+// cycle spans two full sentences, comfortably above it.
+const CHAR_REPETITION_MIN_DISTINCT_CHARS = 8;
+
+export type CharRepetitionCheck = SequencePeriodCheck;
+
+/**
+ * Whether the tail of `text` is an exact repeat of some short span at least
+ * `CHAR_REPETITION_MIN_REPEATS` times. Pure text-in, decision-out: the caller
+ * (the TUI stall watchdog) owns accumulating the buffer across deltas and
+ * cycles within a turn.
+ *
+ * Delegates to the generic detectSequencePeriod over the character array —
+ * periods longer than `text.length / CHAR_REPETITION_MIN_REPEATS` are skipped
+ * there, not as an arbitrary cutoff but because they cannot mathematically
+ * reach the occurrence threshold within the given text.
+ *
+ * This is deliberately not merged with `detectRepetition` above: that one
+ * normalizes whitespace/invisibles and optionally folds digits before
+ * running a KMP period search tuned for streamed model text, while this is a
+ * plain per-character search with a distinct-chars floor instead of digit
+ * folding, tuned for the TUI's live character buffer. Same question ("is the
+ * tail looping"), different constants and different false-positive shape —
+ * see the config comments on each for why neither threshold set may be
+ * changed to match the other.
+ */
+export function detectCharRepetition(text: string): CharRepetitionCheck {
+  return detectSequencePeriod(text.split(""), {
+    minPeriod: CHAR_REPETITION_MIN_PERIOD,
+    maxPeriod: CHAR_REPETITION_MAX_PERIOD_CAP,
+    minRepeats: CHAR_REPETITION_MIN_REPEATS,
+    minDistinct: () => CHAR_REPETITION_MIN_DISTINCT_CHARS,
+  });
+}

src/tui/stall-watchdog.ts

@@ -1,5 +1,5 @@
 import type { TurnStatus } from "./session-chrome.js";
-import { detectSequencePeriod, type SequencePeriodCheck } from "../util/period-detection.js";
+import { detectCharRepetition, type CharRepetitionCheck } from "../subagent/repetition.js";
 
 // How long the run can be continuously awaiting a response with no new content
 // before the watchdog fires and aborts the in-flight request.
@@ -26,64 +26,13 @@ export interface ShouldAbortForStallArgs {
   readonly activeToolCalls: readonly string[];
 }
 
-// The captured incident looped two sentences with no line break between them
-// ("...ranked findings.Confirming callId emission...") — degeneration is a
-// character-level loop, not a line-level one. Splitting on "\n" misses it
-// entirely, so the tail is treated as a plain string and checked for the
-// smallest period it exactly repeats: the shortest span p such that the last
-// several hundred characters equal p repeated.
-//
-// A period below this is more likely a short structural tic (indentation, a
-// repeated bullet or table-cell divider) than a looping phrase. Live loops
-// repeat units as short as 10 chars ("Groaning. " emitted ~1,363 times), so
-// the floor sits at 8 — short structural tics that survive it (a "- item\n"
-// bullet is 7 chars) fall below, and the ones at or above it are filtered by
-// the distinct-chars floor and the raised repeat bar instead. Still well
-// under the ~140-char period of the captured incident's two-sentence cycle.
-const REPETITION_MIN_PERIOD = 8;
-// How many exact repeats of the period are required before it counts as a
-// loop rather than a coincidence. Raised 3x in step with the 3x-lower period
-// floor so the minimum exactly-periodic span stays at 192 chars (was 24*8,
-// now 8*24). Verified against real non-degenerate repetition: a 6-row
-// markdown table separator (period ~51 chars, 6 exact repeats) and 3
-// identical code lines (period ~60 chars, 3 exact repeats) both land far
-// under this bar and are not flagged; a genuine degenerate loop repeats
-// hundreds of times, so it still clears the bar long before the stream ends.
-const REPETITION_MIN_REPEATS = 24;
-// Hard ceiling on the period search regardless of buffer size, purely to cap
-// worst-case work per check — token-level degeneration loops on a phrase or
-// two, never on multi-paragraph spans.
-const REPETITION_MAX_PERIOD_CAP = 2_000;
-// A monochrome run ("x".repeat(500), a "----" rule, a wall of spaces) is
-// trivially periodic at *every* period, which would otherwise make it the
-// single easiest thing to false-trigger on — verified by execution against
-// `thinking-reveal.test.ts`'s burst-of-"x" fixture, which tripped the guard
-// before this floor existed. Requiring the repeating unit itself to contain
-// this many distinct characters keeps single-character and low-variety runs
-// out without weakening the sentence-level case: the captured incident's
-// cycle spans two full sentences, comfortably above it.
-const REPETITION_MIN_DISTINCT_CHARS = 8;
-
-export type RepetitionCheck = SequencePeriodCheck;
+// The character-level tail-repetition search (constants, doc comments, and
+// implementation) lives in ../subagent/repetition.ts as `detectCharRepetition`
+// — consolidated there so this module and the subagent module do not each
+// hand-roll their own repetition detector. Thresholds are unchanged.
+export type RepetitionCheck = CharRepetitionCheck;
 
-/**
- * Whether the tail of `text` is an exact repeat of some short span at least
- * `REPETITION_MIN_REPEATS` times. Pure text-in, decision-out: the caller owns
- * accumulating the buffer across deltas and cycles within a turn.
- *
- * Delegates to the generic detectSequencePeriod over the character array —
- * periods longer than `text.length / REPETITION_MIN_REPEATS` are skipped
- * there, not as an arbitrary cutoff but because they cannot mathematically
- * reach the occurrence threshold within the given text.
- */
-export function detectRepetition(text: string): RepetitionCheck {
-  return detectSequencePeriod(text.split(""), {
-    minPeriod: REPETITION_MIN_PERIOD,
-    maxPeriod: REPETITION_MAX_PERIOD_CAP,
-    minRepeats: REPETITION_MIN_REPEATS,
-    minDistinct: () => REPETITION_MIN_DISTINCT_CHARS,
-  });
-}
+export const detectRepetition = detectCharRepetition;
 
 /**
  * Whether silence of `thresholdMs` counts as stuck at all. Shared by the notice