pi-anti-doom-loop 0.0.2 → 0.0.3

package/README.md

@@ -15,17 +15,18 @@ pi install npm:pi-anti-doom-loop
 
 ## What it detects
 
-| Signal                          | Default                 | Blocked when                                                    |
-| ------------------------------- | ----------------------- | --------------------------------------------------------------- |
-| Same `(tool, args)` repeated    | 3× in the last 10 calls | The pattern has repeated `3` times with no change               |
-| Same tool failing consecutively | 3×                      | A tool errored `3` times in a row — stop retrying it blindly    |
-| Same assistant text verbatim    | 3× in a row             | The model re-emitted identical text `3` times (text-only loops) |
+| Signal                           | Default                 | Blocked when                                                                             |
+| -------------------------------- | ----------------------- | ---------------------------------------------------------------------------------------- |
+| Same `(tool, args)` repeated     | 3× in the last 10 calls | The pattern has repeated `3` times with no change                                        |
+| Same tool failing consecutively  | 3×                      | A tool errored `3` times in a row — stop retrying it blindly                             |
+| Same assistant text verbatim     | 3× in a row             | The model re-emitted identical text `3` times (text-only loops)                          |
+| Same sentence inside ONE message | 3×                      | A sentence repeats `3`+ times within a single message (growing self-concatenation loops) |
 
 Blocks hand the model an instructive reason ("change your approach, use a
 different tool, or ask the user"). If the model ignores the block and re-issues
-the exact same call, the turn is **aborted** and you are notified. A verbatim
-text loop (no tool calls involved) aborts the run immediately with a
-notification.
+the exact same call, the turn is **aborted** and you are notified. Verbatim
+text loops and within-message self-repetition (no tool calls involved) abort
+the run immediately with a notification.
 
 Counters reset on every user prompt, so a task legitimately repeated later in
 the same session is never a false positive.

package/extensions/detector.ts

@@ -142,6 +142,23 @@ export class LoopDetector {
   checkText(text: string): Result<{ reason: string }, undefined> {
     const norm = normalizeText(text);
     if (!norm) return Result.err(undefined); // blank text is not a loop signal
+
+    // Within-message self-repetition: the model pastes the same sentence
+    // `textRepeatThreshold`+ times inside ONE message (growing loops like
+    // "…X:…X:…X"). Liquid.ai's loop definition — a section repeats at least N
+    // times. No streak needed: the message itself is the loop.
+    if (!this.textFired) {
+      const chunk = repeatedSegment(norm, this.opts.textRepeatThreshold);
+      if (chunk !== null) {
+        this.textFired = true;
+        return Result.ok({
+          reason:
+            `Assistant message repeats "${truncate(chunk, 60)}" ${this.opts.textRepeatThreshold}+ times ` +
+            `within a single message. You appear to be in a loop — this run is aborted.`,
+        });
+      }
+    }
+
     this.textStreak = norm === this.lastText ? this.textStreak + 1 : 1;
     this.lastText = norm;
     if (this.textStreak >= this.opts.textRepeatThreshold && !this.textFired) {
@@ -192,6 +209,33 @@ export function truncate(text: string, max: number): string {
   return text.length <= max ? text : `${text.slice(0, max)}…`;
 }
 
+/** Minimum length of a segment worth treating as a repeated loop chunk. */
+export const MIN_REPEAT_CHUNK = 16;
+
+/**
+ * Returns the first sentence-ish segment that repeats `threshold` times
+ * within a single normalized message, or null.
+ *
+ * Catches growing doom loops where the model self-concatenates the same
+ * sentence ("…X:…X:…X") — the pattern that evaded cross-message verbatim
+ * detection in production (each message differs, so no streak forms).
+ * Short segments (< MIN_REPEAT_CHUNK) are ignored so pasted logs with
+ * repeated one-word lines never false-positive.
+ */
+export function repeatedSegment(normalized: string, threshold: number): string | null {
+  const segments = normalized
+    .split(/(?<=[.:!?])\s*/)
+    .map((s) => s.trim().replace(/[.:!?]+$/, ""))
+    .filter((s) => s.length >= MIN_REPEAT_CHUNK);
+  const counts = new Map<string, number>();
+  for (const seg of segments) {
+    const n = (counts.get(seg) ?? 0) + 1;
+    if (n >= threshold) return seg;
+    counts.set(seg, n);
+  }
+  return null;
+}
+
 // --- self-check (runs under `node extensions/detector.ts`, skipped when loaded by pi) ---
 if (import.meta.main) {
   const opts: LoopOptions = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-anti-doom-loop",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Detect and break agent doom loops in pi: blocks identical repeated tool calls and blind retries before they burn tokens.",
   "keywords": [
     "anti-doom-loop",