Drop stall-watchdog re-export shim, point consumers at repetition.ts directly

Removed the RepetitionCheck/detectRepetition compatibility re-exports from
stall-watchdog.ts — with only two consumers (turn-state.ts and
stall-watchdog.test.ts) an alias for an internal module wasn't earning its
keep. Both now import directly from subagent/repetition.js.

Renamed the moved function to detectTailCharLoop (TailCharLoopCheck) so it
reads clearly next to subagent/repetition.ts's existing detectRepetition
(the KMP + digit-folding detector for streamed model text) rather than
shadowing its name. Threshold values (8 / 24 / 2000 / 8) unchanged.

CL-6939 / CL-6790.

Author: TheGreatAxios

src/subagent/repetition.ts

@@ -8,7 +8,7 @@
  * 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
+ * guard (`detectTailCharLoop`) — 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
@@ -293,7 +293,7 @@ const CHAR_REPETITION_MAX_PERIOD_CAP = 2_000;
 // cycle spans two full sentences, comfortably above it.
 const CHAR_REPETITION_MIN_DISTINCT_CHARS = 8;
 
-export type CharRepetitionCheck = SequencePeriodCheck;
+export type TailCharLoopCheck = SequencePeriodCheck;
 
 /**
  * Whether the tail of `text` is an exact repeat of some short span at least
@@ -315,7 +315,7 @@ export type CharRepetitionCheck = SequencePeriodCheck;
  * see the config comments on each for why neither threshold set may be
  * changed to match the other.
  */
-export function detectCharRepetition(text: string): CharRepetitionCheck {
+export function detectTailCharLoop(text: string): TailCharLoopCheck {
   return detectSequencePeriod(text.split(""), {
     minPeriod: CHAR_REPETITION_MIN_PERIOD,
     maxPeriod: CHAR_REPETITION_MAX_PERIOD_CAP,

src/tui/stall-watchdog.test.ts

@@ -2,7 +2,6 @@ import { describe, expect, test } from "bun:test";
 
 import {
   applyStallRecovery,
-  detectRepetition,
   isStalledForDisplay,
   repetitionRecoveryMessage,
   shouldAbortForStall,
@@ -12,6 +11,7 @@ import {
   STALL_RECOVERY_MESSAGE,
   STALL_TIMEOUT_MS,
 } from "./stall-watchdog.js";
+import { detectTailCharLoop } from "../subagent/repetition.js";
 
 describe("shouldAbortForStall", () => {
   // Mid-stream hang: tokens already flowed, then everything went silent —
@@ -140,14 +140,14 @@ describe("applyStallRecovery", () => {
   });
 });
 
-describe("detectRepetition", () => {
+describe("detectTailCharLoop", () => {
   test("finds nothing in fresh, varied output", () => {
     const text = [
       "I'll check the callId emission path first.",
       "Running the search now.",
       "Found three matches across the module.",
     ].join("\n");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 
   // The captured incident: the two sentences ran together with no line break
@@ -158,7 +158,7 @@ describe("detectRepetition", () => {
       "I'll verify callId emission and remaining edges, then write the ranked findings.";
     const line2 = "Confirming callId emission, then writing the ranked findings.";
     const text = Array(30).fill(`${line1}${line2}`).join("");
-    const check = detectRepetition(text);
+    const check = detectTailCharLoop(text);
     expect(check.repeating).toBe(true);
     expect(check.period).toBe(line1.length + line2.length);
   });
@@ -168,7 +168,7 @@ describe("detectRepetition", () => {
   // chars keeps it above REPETITION_MIN_DISTINCT_CHARS.
   test("flags a short-phrase loop with a 10-char unit", () => {
     const text = "Groaning. ".repeat(60);
-    const check = detectRepetition(text);
+    const check = detectTailCharLoop(text);
     expect(check.repeating).toBe(true);
     expect(check.period).toBe("Groaning. ".length);
   });
@@ -180,35 +180,35 @@ describe("detectRepetition", () => {
     // Fewer than the occurrence threshold: a model can legitimately restate
     // a step once or twice across tool-call cycles without looping.
     const text = Array(4).fill(`${line1}${line2}`).join("");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 
   test("does not flag a repeated markdown table separator row", () => {
     const row = "| ---------------------- | ---------------------- |";
     const text = Array(6).fill(row).join("\n");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 
   test("does not flag a few identical code lines", () => {
     const line = "  const result = await fetchData(request, options, context)";
     const text = Array(3).fill(line).join("\n");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 
   test("ignores short recurring fragments", () => {
     const text = Array(10).fill("ok").join(" ");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 
   // A monochrome run is periodic at every period by construction — the
   // easiest thing to false-trigger on if entropy is not checked.
   test("does not flag a long run of the same character", () => {
-    expect(detectRepetition("x".repeat(500)).repeating).toBe(false);
+    expect(detectTailCharLoop("x".repeat(500)).repeating).toBe(false);
   });
 
   test("does not flag a repeated horizontal rule", () => {
     const text = Array(10).fill("----------------------------").join("\n");
-    expect(detectRepetition(text).repeating).toBe(false);
+    expect(detectTailCharLoop(text).repeating).toBe(false);
   });
 });
 

src/tui/stall-watchdog.ts

@@ -1,5 +1,4 @@
 import type { TurnStatus } from "./session-chrome.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,14 +25,6 @@ export interface ShouldAbortForStallArgs {
   readonly activeToolCalls: readonly string[];
 }
 
-// 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;
-
-export const detectRepetition = detectCharRepetition;
-
 /**
  * Whether silence of `thresholdMs` counts as stuck at all. Shared by the notice
  * and the abort so they never disagree about which runs are stalled — only

src/tui/turn-state.ts

@@ -11,15 +11,15 @@
 
 import { type } from "arktype";
 
-import { detectRepetition } from "./stall-watchdog.js";
+import { detectTailCharLoop } from "../subagent/repetition.js";
 import type { TurnStatus } from "./session-chrome.js";
 
 // Bound on the accumulated stream text kept for repetition checks. Comfortably
-// larger than the periods `detectRepetition` can confirm, so trimming never
+// larger than the periods `detectTailCharLoop` can confirm, so trimming never
 // drops content the check still needs.
 const STREAM_TEXT_BUFFER_CHARS = 8_000;
 
-// `detectRepetition` walks a character-level period search; cheap per call,
+// `detectTailCharLoop` walks a character-level period search; cheap per call,
 // but the reactor loop can emit a delta per token, and running it on every
 // single one makes it the hottest thing in that loop for no benefit — a
 // repeating tail does not appear or disappear between two three-character
@@ -108,7 +108,7 @@ export interface TurnState {
    * narrating a similar short line before each of several tool calls is
    * ordinary and must not accumulate into an apparent loop, whereas a
    * genuinely degenerate model repeats within one unbroken stream. Bounded to
-   * `STREAM_TEXT_BUFFER_CHARS`; feeds `detectRepetition`, nothing else.
+   * `STREAM_TEXT_BUFFER_CHARS`; feeds `detectTailCharLoop`, nothing else.
    */
   readonly streamText: string;
   /**
@@ -117,9 +117,9 @@ export interface TurnState {
    * throttle below tell "40 more chars arrived" from "the buffer is full."
    */
   readonly streamCharsSeen: number;
-  /** `streamCharsSeen` as of the last `detectRepetition` call. */
+  /** `streamCharsSeen` as of the last `detectTailCharLoop` call. */
   readonly repetitionCheckedAt: number;
-  /** Result of the most recent `detectRepetition` check on `streamText`. */
+  /** Result of the most recent `detectTailCharLoop` check on `streamText`. */
   readonly repeating: boolean;
   /**
    * `streamTokenCount` at the moment repetition was first observed this turn.
@@ -138,7 +138,7 @@ export interface TurnState {
    * Consecutive completed cycles whose fingerprint matched the one before it.
    * A model repeating the same block every cycle, with a tool call in
    * between each, builds this streak even though no single cycle's text ever
-   * gets long enough to trip `detectRepetition` on its own.
+   * gets long enough to trip `detectTailCharLoop` on its own.
    */
   readonly consecutiveMatchingCycles: number;
   /**
@@ -458,7 +458,7 @@ const streaming = (
   // starts empty (see `runningTool`) and would otherwise read back false on
   // the next check, un-latching a real detection the moment a tool call
   // interrupts the stream.
-  const repeating = state.repeating || (due && detectRepetition(streamText).repeating);
+  const repeating = state.repeating || (due && detectTailCharLoop(streamText).repeating);
   return {
     ...state,
     status: state.status === "blocked" ? "blocked" : "running",