pi-anti-doom-loop 0.0.4 → 0.0.5

package/CHANGELOG.md

@@ -0,0 +1,84 @@
+# Changelog
+
+All notable changes to **pi-anti-doom-loop**.
+
+## [0.0.5] — 2026-08-05
+
+### Added
+
+- **`/loopcheck suspend` / `resume`** — escape hatch: pause detection until the next prompt when repetition is intentional (polling, retrying a deploy). No env restart needed.
+- **Session counters** — `steers`/`aborts` appear in `/loopcheck` status; session-scoped (survive per-prompt resets, reset on `/loopcheck reset` or new session).
+- Fixture for the live regex-repeat capture (`parameter\s+(\S+)\s+("` 3× in one message) — regression-covered via the within-message signal.
+- `CHANGELOG.md` ships in the tarball.
+
+### Tests
+
+- 72 → 75: suspend/resume lifecycle, session counters, regex-repeat fixture, `/loopcheck` subcommands.
+
+## [0.0.4] — 2026-08-05
+
+### Added
+
+- **Near-identical text detection** — token-set Jaccard similarity ≥ 0.55 on consecutive assistant messages counts as a loop streak. Catches rephrasing loops where the model changes one or two words per turn ("inspect the failing test" → "examine the failing assertion") that exact matching missed.
+- **Escalation ladder for text loops: steer → abort → bounded resume** — the first detection steers the agent mid-run (injects guidance, work continues); a persistent loop aborts the run and queues **one** fresh-resume directive (`followUp`) so work continues with a new approach; further looping aborts for real and hands control back. The auto-resume budget is session-scoped so a stuck model cannot cycle forever.
+- Detector now fires on every message while a loop condition holds; the controller turns the 1st into a steer, later ones into aborts.
+- Tests: 65 → 72 (token-similarity unit cases, near-identical streak + reset, steer→abort→resume ladder, budget persistence, adapter wiring, fuzz no-FP + injected-3× properties).
+
+## [0.0.3] — 2026-08-05
+
+### Added
+
+- **Within-message self-repetition detection** — a sentence repeating 3+ times inside ONE message (growing self-concatenation loops like "…X:…X:…X") now aborts/steers immediately. Liquid Antidoom's loop definition ("a section repeats at least N times").
+- Segmenter ignores chunks < 16 chars so pasted logs with repeated one-word lines never false-positive.
+- Fixtures for the production growing-loop capture (exact + spaced variants).
+
+### Fixed
+
+- Production gap: loops that grow by self-concatenation evaded both verbatim-streak (messages differ) and identical-call (args vary) detection. Now caught at the message itself.
+
+### Tests
+
+- 51 → 65: `repeatedSegment` unit cases, growing-pattern `checkText` cases, fixture controller paths, fuzz no-FP + injected-3× properties.
+
+## [0.0.2] — 2026-08-05
+
+### Added
+
+- **Full test suite** — Node's built-in `node:test`, no framework:
+  - unit (detector semantics, options clamping, helpers)
+  - fixtures (real doom-loop transcripts: CI-log loops, verbatim repeats; healthy sessions not flagged)
+  - fuzz (seeded: never throws, no false positives, injected loops always block)
+  - integration (controller + adapter driven through a fake `PiLike`)
+  - e2e (real subprocesses: detector self-check, version guard, tarball contents)
+- **`controller.ts`** — extracted all event logic into a pure, pi-free, testable module; `index.ts` became a thin structural adapter.
+- `npm test`, `engines >= 22.18`, `files` includes `scripts/`.
+
+### Fixed
+
+- Thresholds clamped to a minimum of 2 (a config of 1 would brick the agent — deepsec finding).
+- GitHub Actions pinned to commit SHAs (NPM_TOKEN in scope — deepsec finding).
+- Release job `concurrency` group (publish race / TOCTOU).
+- `npm publish --dry-run` preflight before the real publish.
+- Version guard requires the git tag `v$version` on the manual-dispatch path.
+
+### Changed
+
+- Leveraged `better-result` (detector decisions) and `effect` v4 (release guard).
+
+## [0.0.1] — 2026-08-05
+
+### Added
+
+- Initial release. Detects and breaks agent doom loops in pi:
+  - **identical (tool, args) repeated** 3× in the last 10 calls → block with an instructive reason
+  - **same tool failing** 3× consecutively → block with "stop retrying, fix the root cause"
+  - escalation: re-issuing a blocked call aborts the turn
+- `/loopcheck` command (status + reset).
+- Counters reset per user prompt (legit repeated tasks are never false positives).
+- GitHub Actions release workflow: quality gate → version bump guard → dry-run → publish, triggered by `v*` tags.
+- `pi-package` keyword + `pi` manifest for the pi.dev gallery.
+
+[0.0.5]: https://github.com/irfndi/pi-anti-doom-loop/compare/v0.0.4...v0.0.5
+[0.0.4]: https://github.com/irfndi/pi-anti-doom-loop/compare/v0.0.3...v0.0.4
+[0.0.2]: https://github.com/irfndi/pi-anti-doom-loop/compare/v0.0.1...v0.0.2
+[0.0.1]: https://github.com/irfndi/pi-anti-doom-loop/releases/tag/v0.0.1

package/README.md

@@ -51,15 +51,17 @@ Environment variables, read at session/prompt start:
 
 ## Command
 
-- `/loopcheck` — show current thresholds and counters
+- `/loopcheck` — show thresholds, counters (steers/aborts this session), suspend state
 - `/loopcheck reset` — clear counters
+- `/loopcheck suspend` — pause detection until the next prompt (escape hatch for intentional repetition)
+- `/loopcheck resume` — re-enable detection early
 
 ## How it works
 
-Everything hooks into the `tool_call` / `tool_result` events; detection is a
-small sliding-window counter (see `extensions/detector.ts`) with no state kept
-between user prompts. Works with any model — cheap models just trigger it more
-often.
+Everything hooks into the `tool_call` / `tool_result` / `message_end` events;
+detection is a small sliding-window counter (see `extensions/detector.ts`) with
+per-session counters (steers/aborts) tracked in `extensions/controller.ts`.
+Works with any model — cheap models just trigger it more often.
 
 ## Development
 

package/extensions/controller.ts

@@ -63,6 +63,10 @@ export interface AntiLoopController {
   onMessageEnd(role: string, content: unknown): TextLoopOutcome | null;
   /** Full reset (session start, user prompt, /loopcheck reset). */
   reset(): void;
+  /** Suspend detection until the next reset (escape hatch for intentional repetition). */
+  suspend(): void;
+  resume(): void;
+  isSuspended(): boolean;
   /** Human-readable status with thresholds + counters for /loopcheck. */
   status(): string;
 }
@@ -72,9 +76,13 @@ export function createController(opts: LoopOptions = readOptions()): AntiLoopCon
   const blockedIds = new Set<string>();
   let steered = false;
   let resumes = 0;
+  let steers = 0;
+  let aborts = 0;
+  let suspended = false;
 
   return {
     onToolCall(toolName, input, toolCallId) {
+      if (suspended) return null;
       const decision = detector.check(toolName, input);
       if (decision.isErr()) {
         detector.record(toolName, input);
@@ -96,6 +104,7 @@ export function createController(opts: LoopOptions = readOptions()): AntiLoopCon
     },
 
     onMessageEnd(role, content) {
+      if (suspended) return null;
       if (role !== "assistant") return null;
       const text = extractText(content);
       if (!text) return null;
@@ -105,12 +114,15 @@ export function createController(opts: LoopOptions = readOptions()): AntiLoopCon
       const reason = hit.value.reason;
       if (!steered) {
         steered = true;
+        steers++;
         return { reason, action: "steer", resume: false };
       }
       if (resumes < RESUME_BUDGET) {
         resumes++;
+        aborts++;
         return { reason, action: "abort", resume: true };
       }
+      aborts++;
       return { reason, action: "abort", resume: false };
     },
 
@@ -118,15 +130,31 @@ export function createController(opts: LoopOptions = readOptions()): AntiLoopCon
       detector = new LoopDetector(opts);
       blockedIds.clear();
       steered = false;
-      // resumes is intentionally NOT reset here: the auto-resume budget is
-      // session-scoped so a stuck model cannot cycle steer→abort forever.
+      suspended = false;
+      // resumes/steers/aborts are intentionally NOT reset here: they are
+      // session-scoped so a stuck model cannot cycle steer→abort forever and
+      // /loopcheck can report lifetime counters.
+    },
+
+    suspend() {
+      suspended = true;
+    },
+
+    resume() {
+      suspended = false;
+    },
+
+    isSuspended() {
+      return suspended;
     },
 
     status() {
       const o = detector.opts;
+      const s = suspended ? ", suspended" : "";
       return (
         `anti-doom-loop: repeats>=${o.repeatThreshold}/window ${o.windowSize}, ` +
-        `fails>=${o.failThreshold}, text>=${o.textRepeatThreshold}. ${detector.summary()}`
+        `fails>=${o.failThreshold}, text>=${o.textRepeatThreshold}. ${detector.summary()} ` +
+        `steers=${steers} aborts=${aborts}${s}`
       );
     },
   };

package/extensions/index.ts

@@ -73,7 +73,8 @@ export default function (pi: PiLike): void {
   pi.on("session_start", () => reset());
 
   // Fresh counters per user prompt: only the loop happening *right now* counts.
-  pi.on("before_agent_start", () => reset());
+  // Internal reset keeps session-scoped steers/aborts/resume budget.
+  pi.on("before_agent_start", () => controller.reset());
 
   pi.on("tool_call", (event: ToolCallEventLite, ctx: CtxLite) => {
     const outcome = controller.onToolCall(event.toolName, event.input, event.toolCallId);
@@ -118,11 +119,22 @@ export default function (pi: PiLike): void {
   pi.registerCommand("loopcheck", {
     description: "Anti-doom-loop status; `/loopcheck reset` clears counters",
     handler: async (args: string, ctx: CommandCtxLite) => {
-      if (args.trim().toLowerCase() === "reset") {
+      const arg = args.trim().toLowerCase();
+      if (arg === "reset") {
         reset();
         ctx.ui.notify("Anti-doom-loop: counters reset", "info");
         return;
       }
+      if (arg === "suspend") {
+        controller.suspend();
+        ctx.ui.notify("Anti-doom-loop: suspended until the next prompt", "info");
+        return;
+      }
+      if (arg === "resume") {
+        controller.resume();
+        ctx.ui.notify("Anti-doom-loop: resumed", "info");
+        return;
+      }
       ctx.ui.notify(controller.status(), "info");
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-anti-doom-loop",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "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",
@@ -17,7 +17,8 @@
   },
   "files": [
     "extensions",
-    "scripts"
+    "scripts",
+    "CHANGELOG.md"
   ],
   "type": "module",
   "main": "extensions/index.ts",