Detect repetition by character period, not by line

Line-splitting missed the captured incident outright: the looping
sentences ran together with no newline between them, so the whole
span collapsed into one line and never reached the occurrence check.
Detection now finds the smallest period the streamed tail exactly
repeats, which catches the no-newline shape the same way it catches a
line-level loop.

Line counting also flagged ordinary structure — a repeated markdown
table row, a few identical code lines — as degeneration. The period
search requires more repeats and enough character variety in the
repeating unit to rule those out, verified against both plus a
monochrome run (a repeated rule or the same character streamed many
times), which is trivially periodic at every length and would
otherwise be the easiest false trigger of all.

The per-delta check is now throttled to run once per chunk of new
text rather than once per token, since a repeating tail cannot appear
or disappear between two three-character tokens. The idle notice also
now checks the repetition flag directly, so a stream that is looping
but not silent can no longer be labeled a silent hang.

Author: TheGreatAxios

src/tui-opentui/runtime-bridge.ts

@@ -924,6 +924,14 @@ export function attachSessionBridge(
     // Content-based, not time-based: a repeating line means the model is
     // stuck regardless of how fast it is producing it, so this is checked
     // before the silence clock rather than folded into it.
+    //
+    // Gated on `status === "running"` because every turn-ending transition
+    // (interrupt, connector.reply with no tools outstanding, reactor.done /
+    // reactor.error) routes through `initialTurnState`, which clears
+    // `repeating`. If a future settle path changes `isProcessing` without
+    // also resetting `status` and `repeating` through that same reset, this
+    // guard would no longer mean "the turn is actually live" and could fire
+    // on an already-settled turn — recheck this alongside any such change.
     if (bag.turn.status === "running" && bag.turn.repeating) {
       const repeatedTokens =
         bag.turn.streamTokenCount - (bag.turn.repeatingSinceTokenCount ?? 0)
@@ -954,7 +962,13 @@ export function attachSessionBridge(
 
     // Notice only — the phase still paints below, because a ramp that stops
     // moving is the very thing that reads as a hang.
-    if (shouldNoticeStall({ ...stallArgs, stallNoticeMs })) {
+    if (
+      shouldNoticeStall({
+        ...stallArgs,
+        stallNoticeMs,
+        repeating: bag.turn.repeating,
+      })
+    ) {
       setStatusFlash(shell, STALL_NOTICE_MESSAGE)
     }
 

src/tui-opentui/stall-watchdog.test.ts

@@ -112,26 +112,54 @@ describe("detectRepetition", () => {
     expect(detectRepetition(text).repeating).toBe(false)
   })
 
-  test("flags a line repeated past the occurrence threshold", () => {
+  // The captured incident: the two sentences ran together with no line break
+  // at all. A line-splitting detector never sees this; the period search
+  // does not care where (or whether) the lines break.
+  test("flags the captured incident string verbatim, with no newlines", () => {
     const line1 =
       "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(4).fill([line1, line2]).flat().join("\n")
+    const text = Array(10).fill(`${line1}${line2}`).join("")
     const check = detectRepetition(text)
     expect(check.repeating).toBe(true)
-    expect(check.repeatedLine).toBe(line1)
-    expect(check.occurrences).toBeGreaterThanOrEqual(3)
+    expect(check.period).toBe(line1.length + line2.length)
   })
 
-  test("ignores short recurring lines", () => {
-    const text = Array(6).fill("Checking...").join("\n")
+  test("does not flag the same cycle a handful of times", () => {
+    const line1 =
+      "I'll verify callId emission and remaining edges, then write the ranked findings."
+    const line2 = "Confirming callId emission, then writing the ranked findings."
+    // 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)
   })
 
-  test("does not flag two occurrences", () => {
-    const line =
-      "I'll verify callId emission and remaining edges, then write the ranked findings."
-    const text = [line, "some other progress here.", line].join("\n")
+  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)
+  })
+
+  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)
+  })
+
+  test("ignores short recurring fragments", () => {
+    const text = Array(10).fill("ok").join(" ")
+    expect(detectRepetition(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)
+  })
+
+  test("does not flag a repeated horizontal rule", () => {
+    const text = Array(10).fill("----------------------------").join("\n")
     expect(detectRepetition(text).repeating).toBe(false)
   })
 })
@@ -154,8 +182,13 @@ describe("shouldNoticeStall", () => {
     stallNoticeMs: STALL_NOTICE_MS,
     isProcessing: true,
     streamingType: null,
+    repeating: false,
   }
 
+  test("stays quiet while repeating, even if also silent by the clock", () => {
+    expect(shouldNoticeStall({ ...base, repeating: true })).toBe(false)
+  })
+
   test("speaks up long before the abort backstop", () => {
     expect(STALL_NOTICE_MS).toBeLessThan(STALL_TIMEOUT_MS)
     expect(shouldNoticeStall(base)).toBe(true)

src/tui-opentui/stall-watchdog.ts

@@ -21,41 +21,88 @@ export type ShouldAbortForStallArgs = {
   readonly streamingType: "text" | "thinking" | "tool" | null
 }
 
-// A repeated line has to be long enough that short, legitimately-recurring
-// fragments ("Let me check.") do not trip the guard.
-const REPETITION_MIN_LINE_LENGTH = 20
-// How far back into the streamed text to look for repeats. Bounded so the
-// check stays cheap however long the turn runs.
-const REPETITION_LOOKBACK_LINES = 12
-// Three verbatim repeats of the same substantial line is not a coincidence
-// of phrasing — it is the model looping.
-const REPETITION_MIN_OCCURRENCES = 3
+// 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. Chosen well
+// under the ~140-char period of the captured incident's two-sentence cycle,
+// with headroom for shorter degenerate loops (a single repeated sentence).
+const REPETITION_MIN_PERIOD = 24
+// How many exact repeats of the period are required before it counts as a
+// loop rather than a coincidence. 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 under this bar and are not flagged; the captured incident's
+// sentence pair comfortably clears it well before the stream ends.
+const REPETITION_MIN_REPEATS = 8
+// 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 = {
   readonly repeating: boolean
-  readonly repeatedLine: string | null
-  readonly occurrences: number
+  readonly period: number | null
+  readonly repeats: number
 }
 
 /**
- * Whether the tail of the streamed text is dominated by a line repeated
- * verbatim. Pure text-in, decision-out: the caller owns accumulating the
- * buffer across deltas and cycles within a turn.
+ * Length of the exact-period run ending at the last character of `text`,
+ * including the base period itself. `text[i] === text[i - period]` walked
+ * backwards from the end; stops at the first mismatch or the start of the
+ * string.
+ */
+function periodicSuffixLength(text: string, period: number): number {
+  let i = text.length - 1
+  let j = i - period
+  let matched = 0
+  while (j >= 0 && text[i] === text[j]) {
+    matched++
+    i--
+    j--
+  }
+  return matched + period
+}
+
+/**
+ * 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.
+ *
+ * Periods longer than `text.length / REPETITION_MIN_REPEATS` are skipped, not
+ * as an arbitrary cutoff but because they cannot mathematically reach the
+ * occurrence threshold within the given text — a loop with a longer period
+ * needs a longer buffer to confirm, which is a buffer-size trade-off owned by
+ * the caller, not a second detection path here.
  */
 export function detectRepetition(text: string): RepetitionCheck {
-  const lines = text
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.length >= REPETITION_MIN_LINE_LENGTH)
-  const tail = lines.slice(-REPETITION_LOOKBACK_LINES)
-  const counts = new Map<string, number>()
-  for (const line of tail) counts.set(line, (counts.get(line) ?? 0) + 1)
-  for (const [line, occurrences] of counts) {
-    if (occurrences >= REPETITION_MIN_OCCURRENCES) {
-      return { repeating: true, repeatedLine: line, occurrences }
-    }
+  const maxPeriod = Math.min(
+    REPETITION_MAX_PERIOD_CAP,
+    Math.floor(text.length / REPETITION_MIN_REPEATS),
+  )
+  for (let period = REPETITION_MIN_PERIOD; period <= maxPeriod; period++) {
+    const matched = periodicSuffixLength(text, period)
+    const repeats = matched / period
+    if (repeats < REPETITION_MIN_REPEATS) continue
+    const unit = text.slice(text.length - period)
+    if (new Set(unit).size < REPETITION_MIN_DISTINCT_CHARS) continue
+    return { repeating: true, period, repeats }
   }
-  return { repeating: false, repeatedLine: null, occurrences: 0 }
+  return { repeating: false, period: null, repeats: 0 }
 }
 
 /**
@@ -87,14 +134,18 @@ export function shouldAbortForStall(args: ShouldAbortForStallArgs): boolean {
 
 export type ShouldNoticeStallArgs = ShouldAbortForStallArgs & {
   readonly stallNoticeMs: number
+  /** Whether the repetition guard currently sees a looping tail. */
+  readonly repeating: boolean
 }
 
 /**
  * Returns true while the run has been silent long enough to say so but not yet
  * long enough to abort. False once the abort takes over, so the two never
- * paint at the same time.
+ * paint at the same time, and false while repeating — that run is producing
+ * output, just not useful output, and "no response" would misdescribe it.
  */
 export function shouldNoticeStall(args: ShouldNoticeStallArgs): boolean {
+  if (args.repeating) return false
   if (shouldAbortForStall(args)) return false
   return silentPastThreshold(args, args.stallNoticeMs)
 }

src/tui-opentui/turn-monitor.test.ts

@@ -377,15 +377,18 @@ describe("repetition guard", () => {
         t.bridge.submit("build it", "immediate")
         t.port.clear()
 
+        // The captured incident shape: the two sentences run together with
+        // no line break between cycles.
         const line1 =
-          "I'll verify callId emission and remaining edges, then write the ranked findings.\n"
-        const line2 = "Confirming callId emission, then writing the ranked findings.\n"
+          "I'll verify callId emission and remaining edges, then write the ranked findings."
+        const line2 = "Confirming callId emission, then writing the ranked findings."
+        const cycle = `${line1}${line2}`
 
         // Tokens keep landing every tick — a real stall would never fire here.
-        for (let i = 0; i < 6; i++) {
+        for (let i = 0; i < 10; i++) {
           t.bridge.handle({
             type: "inference.text.delta",
-            data: { token: i % 2 === 0 ? line1 : line2 },
+            data: { token: cycle },
           })
           t.advance(10)
           t.tick()

src/tui-opentui/turn-state.test.ts

@@ -193,8 +193,10 @@ describe("turn transitions", () => {
 describe("repetition tracking", () => {
   const line1 =
     "I'll verify callId emission and remaining edges, then write the ranked findings."
-  const line2 =
-    "Confirming callId emission, then writing the ranked findings."
+  const line2 = "Confirming callId emission, then writing the ranked findings."
+  // The captured incident shape: the two sentences run together with no
+  // separator, each delta landing as one full cycle.
+  const cycle = `${line1}${line2}`
 
   const textDelta = (text: string) => ({
     type: "inference.text.delta",
@@ -212,23 +214,27 @@ describe("repetition tracking", () => {
     expect(s.repeatingSinceTokenCount).toBeNull()
   })
 
-  test("a line looping past the threshold flips repeating and latches the token count", () => {
-    const deltas = Array(4)
-      .fill([line1, line2])
-      .flat()
-      .map((line) => textDelta(`${line}\n`))
+  test("the captured incident shape (no separator between cycles) flips repeating", () => {
+    const deltas = Array(10)
+      .fill(cycle)
+      .map((text) => textDelta(text))
     const s = fold([{ type: "inference.start" }, ...deltas])
     expect(s.repeating).toBe(true)
-    // Three text deltas land before the third `line1` repeat crosses the
-    // occurrence threshold and latches the count.
-    expect(s.repeatingSinceTokenCount).toBe(5)
+    expect(s.repeatingSinceTokenCount).not.toBeNull()
+  })
+
+  test("a couple of restated cycles across tool calls is not a loop", () => {
+    const deltas = Array(3)
+      .fill(cycle)
+      .map((text) => textDelta(text))
+    const s = fold([{ type: "inference.start" }, ...deltas])
+    expect(s.repeating).toBe(false)
   })
 
   test("repetition tracked across a tool cycle survives connector.reply with tools outstanding", () => {
-    const deltas = Array(4)
-      .fill([line1, line2])
-      .flat()
-      .map((line) => textDelta(`${line}\n`))
+    const deltas = Array(10)
+      .fill(cycle)
+      .map((text) => textDelta(text))
     const withTool = turnStateFromEvent(
       fold([{ type: "inference.start" }, ...deltas]),
       { type: "tool.start", data: { call: { id: "c1", name: "grep" } } },
@@ -244,10 +250,9 @@ describe("repetition tracking", () => {
   })
 
   test("a fresh submit clears the repetition state", () => {
-    const deltas = Array(4)
-      .fill([line1, line2])
-      .flat()
-      .map((line) => textDelta(`${line}\n`))
+    const deltas = Array(10)
+      .fill(cycle)
+      .map((text) => textDelta(text))
     const looping = fold([{ type: "inference.start" }, ...deltas])
     const restarted = turnStateOnSubmit(looping, 200)
     expect(restarted.repeating).toBe(false)