pi-antiloop 1.0.0 → 1.1.0

package/README.md

@@ -1,18 +1,18 @@
 <div align="center">
 
-![Antiloop banner](docs/banner.png)
+![Antiloop banner](https://raw.githubusercontent.com/noguerol/antiloop/main/docs/banner.jpeg)
 
 </div>
 
 # Antiloop — Loop Detection and Break for pi
 
-**Antiloop watches every assistant message, tool call and thinking block, and forces the model out of reasoning loops before they eat your context and your patience.** Three simultaneous detection strategies (text similarity, tool-call sequences, thinking content) find loops that humans miss — and progressive intervention (warning → force break → abort) tells the model to take a different approach, without you having to babysit it.
+**Antiloop watches every assistant message, tool call and thinking block, and forces the model out of reasoning loops before they eat your context and your patience.** Four simultaneous detection strategies (text similarity, tool-call sequences, thinking content, structural openings) find loops that humans miss — and progressive intervention (warning → force break → abort) tells the model to take a different approach, without you having to babysit it.
 
 ---
 
 ## Features
 
-- **Four detection strategies** — text repetition (trigram Jaccard + Levenshtein), tool-call sequences (name + argument matching), thinking blocks, and structural opening-phrase patterns
+- **Four detection strategies** — text repetition (trigram Jaccard + Levenshtein), tool-call sequences (name + near-identical arguments + same outcome — result-aware, so retries that make progress don't false-positive), thinking blocks, and structural opening-phrase patterns
 - **Progressive intervention** — `warning` reminds the model to vary its approach; `force break` injects explicit anti-loop instructions and modifies context; `abort` stops the run entirely
 - **Configurable thresholds** — independent dials for similarity cutoff, warning/force-break/abort counts, detection window, and which strategies are on
 - **Sliding window** — only the last N messages are compared, so detection is O(N) in the window size, not in the full session
@@ -100,7 +100,7 @@ Detection strategies:
 
 Recent detections:
   [text] Text similarity 85% with message 3 (2m ago)
-  [tool] Same tool calls repeated: read, edit (5m ago)
+  [tool] repeated 3x: bash (5m ago)
 ```
 
 ### `/antiloop config`
@@ -112,6 +112,9 @@ Interactive menu with current values:
 - **Force break threshold** — similar messages before force break (default 3)
 - **Abort threshold** — similar messages before abort (0 = disabled)
 - **Similarity threshold** — `0.5 / 0.6 / 0.7 / 0.75 / 0.8 / 0.9` — how close two messages must be to count as looping
+- **Tool similarity** — `0.99 / 0.95 / 0.9 / 0.8` — how close tool-call *arguments* must be to count as the same call (95% default: only near-identical repeats loop)
+- **Tool repeat** — `1 / 2 / 3` — prior occurrences of the same call set required before a tool loop flags
+- **Result similarity** — `0.95 / 0.8 / 0.6` — how similar captured results must be to count as the *same outcome* (veto when a repeated command starts succeeding/differing)
 - **Detection window** — `5 / 10 / 15 / 20` — number of recent messages to analyze
 - **Per-strategy toggles** — text / tool / thinking detection
 - **Notifications** — show detection notifications
@@ -123,30 +126,33 @@ Shows the most recent 30 detections with similarity scores and timestamps, newes
 
 ### `/antiloop test`
 
-Runs five built-in cases plus a tool-call equality check to verify the similarity engine is working correctly:
+Runs the real detection engine (not a copy) — text similarity plus tool-call regression cases:
 
 ```
-"Hello world" vs "Hello world"
-  Similarity: 100.0% (expected: identical)
-"Hello world" vs "Hello World!"
-  Similarity: 95.0% (expected: very similar)
-"I will read the file first" vs "I will read the file first to understand"
-  Similarity: 85.0% (expected: similar)
-...
+text identical      → 100% (exp 100%) ✅
+text near-identical → 91% (exp ≥ 80%) ✅
+text unrelated      → 19% (exp < 50%) ✅
+tool identical cmd  → match (exp match) ✅
+tool sweep (flags)  → no match @95% (exp no match) ✅   ← regression: 0.8–0.94 overlap is NOT a loop
+tool sweep (old 80%)→ match @80% (exp match — was the false positive) ✅
+tool different tool → no match (exp no match) ✅
+tool empty lists    → no match (exp no match) ✅
+result same outcome  → match (exp match — PID noise ok) ✅
+result diff outcome  → no match (exp no match — error→success is progress) ✅
 ```
 
 ## How It Works
 
 ### Detection pipeline
 
-After every `message_end` event, antiloop extracts the new assistant content (text, thinking, tool calls) and pushes it onto a sliding window of the last `detectionWindow + 5` messages. Then it runs the active detection strategies against the current window:
+After every assistant `message_end` event, antiloop extracts the new content (text, thinking, tool calls — including their ids) and pushes it onto a sliding window of the last `detectionWindow + 5` messages. Detection itself runs at `turn_end`, once the tool results are known: results are fingerprinted and attached to the tracked calls, then the active detection strategies run against the window:
 
 | Strategy | What it compares | Algorithm |
 |----------|------------------|-----------|
 | Text | Full assistant message text | n-gram Jaccard (≥ 100 chars) or Levenshtein (shorter) |
-| Tool | Tool name + arguments | Sequence match + ≥ 80% args similarity |
+| Tool | Tool name + arguments (+ captured result) | Sequence match + near-identical args (≥ `toolSimilarityThreshold`, default 95%) *and* ≥ `minToolRepeatCount` prior recurrences. **Result veto:** if both runs captured a result and the outcomes differ, it's progress, not a loop |
 | Thinking | Internal reasoning/thinking blocks | Same as text |
-| Structural | First 10 words of each message | Opening-phrase similarity ≥ 80% across ≥ 3 messages |
+| Structural | First 10 words of each message | Opening-phrase similarity ≥ 90% across ≥ 3 messages |
 
 Each detected pair becomes a `LoopDetection { type, similarity, messageIndices, description }` and the consecutive counter increases.
 
@@ -172,10 +178,34 @@ For longer texts:  Character trigram Jaccard
   "I will read the file first to understand the codebase..."
   → ~85% (many shared 3-grams)
 
-For tool calls:  sequence + per-call argument similarity ≥ 80%
-  [read({path:"/src/x.ts"}), edit({path:"/src/x.ts",...})]
-  [read({path:"/src/x.ts"}), edit({path:"/src/x.ts",...})]
-  → matched
+For tool calls:  sequence + per-call argument similarity ≥ 95% (default)
+  [bash("setsid ./llama-server -m … -b 2048 -ctk q8_0 …")]
+  [bash("setsid ./llama-server -m … -b 2048 -ctk q8_0 …")]      → matched (identical)
+
+  …but a parameter sweep is NOT a loop, even at 80–94% similarity:
+  [bash("… -b 2048 -ctk q8_0 -ctv turbo4 > /tmp/sweep-turbo4.log …")]
+  [bash("… -b 8192 -ctk f16  -ctv f16  > /tmp/sweep-b8192.log …")]  → not matched
+
+  Long bash commands share scaffolding (env setup, model path, most flags),
+  so 80% overlap is normal for *different* sequential operations. Only
+  near-identical repeats — the same call set seen `minToolRepeatCount` times
+  inside the window — count as a tool loop.
+
+Result veto (tool loops):  detection runs at `turn_end`, where the tool
+results are known. Each captured result becomes a normalized tail fingerprint
+("err|" / "ok|" prefix + last 400 chars, so PID/timestamp noise is tolerated).
+If the same command produced a *different* outcome, the pair is progress:
+
+  [bash("...")] → err|error: invalid argument: ROCm0        (attempt 1)
+  [bash("...")] → ok|model loaded / listening on :8093      (attempt 2)
+  → NOT a loop — the retry fixed the problem
+
+  [bash("...")] → err|failed to create context …            (attempt 1)
+  [bash("...")] → err|failed to create context …            (attempt 2)
+  → loop signal (same command, same outcome, repeated)
+
+Results only veto; they never trigger on their own, and calls without a
+captured result fall back to argument matching alone.
 ```
 
 ### Sliding window
@@ -193,6 +223,9 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
   "forceBreakThreshold": 3,
   "abortThreshold": 0,
   "similarityThreshold": 0.75,
+  "toolSimilarityThreshold": 0.95,
+  "minToolRepeatCount": 2,
+  "resultSimilarityThreshold": 0.8,
   "detectToolLoops": true,
   "detectThinkingLoops": true,
   "detectTextLoops": true,
@@ -208,7 +241,10 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
 | `warningThreshold` | `2` | Consecutive detections before warning |
 | `forceBreakThreshold` | `3` | Consecutive detections before force break |
 | `abortThreshold` | `0` | Consecutive detections before abort (0 = disabled) |
-| `similarityThreshold` | `0.75` | Minimum similarity (0.0–1.0) to count a pair as looping |
+| `similarityThreshold` | `0.75` | Minimum similarity (0.0–1.0) to count a text/thinking pair as looping |
+| `toolSimilarityThreshold` | `0.95` | How close tool-call arguments must be (0.0–1.0) to count as the *same* call — see [tool loops](#how-it-works) |
+| `minToolRepeatCount` | `2` | Prior occurrences of a near-identical call set required before a tool loop is flagged (2 = same call seen 3×) |
+| `resultSimilarityThreshold` | `0.8` | Minimum similarity between captured result tails to still count as the *same outcome*; below this, a repeated command is treated as progress, not a loop |
 | `detectTextLoops` | `true` | Detect full-text repetition |
 | `detectToolLoops` | `true` | Detect tool-call sequence + argument repetition |
 | `detectThinkingLoops` | `true` | Detect repeated thinking/reasoning content |
@@ -218,12 +254,13 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
 
 ## Best Practices
 
-1. **Start with defaults** — `warning=2 / force-break=3 / similarity=75%` works well for most models.
+1. **Start with defaults** — `warning=2 / force-break=3 / similarity=75% / tool-sim=95%` works well for most models.
 2. **Adjust sensitivity to the model** — small/local models loop more, so lower `warningThreshold` and `similarityThreshold` to catch them early. Big cloud models rarely loop, so you can raise them to avoid false positives.
-3. **Per-strategy toggles** — if the model's reasoning legitimately repeats (e.g. it's working through a checklist), disable `thinking` detection and leave text/tool on.
-4. **Watch the log** — `/antiloop log` shows what's actually triggering. If you see false positives, raise `similarityThreshold` instead of disabling the strategy entirely.
-5. **Let user input clear state** — each user message decays the consecutive counter by 2, so a fresh prompt naturally resets without `/antiloop reset`.
-6. **`/antiloop test`** — if you ever change the similarity engine, run the self-test to verify it still produces expected scores.
+3. **Tool loops are strict on purpose** — a long bash command with env setup + flags scores 80–94% similar to the *next, different* command. Antiloop only flags tool calls that are near-identical (≥ 95%) *and* repeated ≥ `minToolRepeatCount` times, *and* — when results are captured — produced the same outcome. If you still see false positives on sequential operations, raise `toolSimilarityThreshold` (or `minToolRepeatCount`, or `resultSimilarityThreshold`) via `/antiloop config` — don't disable the detector.
+4. **Per-strategy toggles** — if the model's reasoning legitimately repeats (e.g. it's working through a checklist), disable `thinking` detection and leave text/tool on.
+5. **Watch the log** — `/antiloop log` shows what's actually triggering. If you see false positives, raise `similarityThreshold` instead of disabling the strategy entirely.
+6. **Let user input clear state** — each user message decays the consecutive counter by 2, so a fresh prompt naturally resets without `/antiloop reset`.
+7. **`/antiloop test`** — runs the real detection engine (text + tool-call regression cases) to verify calibration after any change.
 
 ## Architecture
 
@@ -233,20 +270,24 @@ antiloop/
 ├── LICENSE             # MIT
 ├── README.md
 ├── docs/
-│   ├── banner.png      # wide README header
-│   └── preview.png     # npm pi.dev preview card
-├── screenshot.png      # full-res master
+│   ├── banner.jpeg      # wide README header
+│   └── preview.jpeg     # npm pi.dev preview card
 └── src/
-    └── index.ts        # full extension (≈975 lines)
+    ├── index.ts        # hooks + intervention pipeline
+    ├── detect.ts       # similarity engine, detection strategies, self-test
+    ├── commands.ts     # /antiloop command handlers + config menu
+    ├── config.ts       # config load/save
+    ├── types.ts        # shared types
+    └── ui.ts           # UI helpers (select, duration)
 ```
 
-Single-file extension with zero external dependencies (only pi's bundled `@earendil-works/pi-coding-agent` + Node built-ins):
+Modular extension with zero external dependencies (only pi's bundled `@earendil-works/pi-coding-agent` + Node built-ins):
 
 - **Levenshtein + trigram Jaccard** hybrid — small texts use edit distance, large texts use n-gram overlap (each is O(N) in text length)
 - **Sliding window** — only the last `detectionWindow` messages participate, capping memory at O(W × message_size)
 - **Early bail** — short messages and empty tool calls skip similarity computation entirely
 - **TUI integration** — uses `ctx.ui.select` for the config menu and the log viewer; `ctx.ui.notify` for state notifications; `ctx.ui.setStatus` for the persistent status bar
-- **Hooks** — `message_end` (track + detect), `input` (decay), `before_agent_start` (inject intervention), `context` (modify context in force-break mode), `turn_end` (refresh status), `session_start` (load config + reset)
+- **Hooks** — `message_end` (track messages + tool call ids), `turn_end` (attach result fingerprints + detect), `input` (decay), `before_agent_start` (inject intervention), `context` (modify context in force-break mode), `session_start` (load config + reset)
 
 ## License
 

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "pi-antiloop",
-  "version": "1.0.0",
-  "description": "A pi extension that detects reasoning/processing loops in any model and forces a break with progressive intervention (warning → force break → abort). Text, tool, thinking and structural similarity detection with configurable thresholds and a self-test command.",
+  "version": "1.1.0",
+  "description": "Antiloop: detect reasoning loops and force a break (warn → force → abort) across text, tool, thinking, and structural patterns. Tool-loop detection is result-aware: only near-identical repeated calls with the same outcome count, so sequential bash operations and retries that make progress don't false-positive.",
   "keywords": [
     "pi-package",
-    "loop-detection",
     "antiloop",
+    "loop-detection",
     "reasoning",
-    "monitoring",
-    "debugging"
+    "monitoring"
   ],
   "author": "Javier Noguerol <https://github.com/noguerol>",
   "license": "MIT",
@@ -24,7 +23,7 @@
     "extensions": [
       "./src/index.ts"
     ],
-    "image": "https://raw.githubusercontent.com/noguerol/antiloop/main/docs/preview.png"
+    "image": "https://raw.githubusercontent.com/noguerol/antiloop/main/docs/preview.jpeg"
   },
   "files": [
     "src"

package/src/commands.ts

@@ -0,0 +1,230 @@
+// antiloop — command handlers. Lazy-loaded on /antiloop.
+
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { saveConfig } from "./config.ts";
+import type { AntiloopState, Runtime } from "./types.ts";
+import { formatDuration, selectFrom } from "./ui.ts";
+
+export async function handleCommand(
+	args: string | undefined,
+	ctx: ExtensionCommandContext,
+	rt: Runtime,
+): Promise<void> {
+	const sub = (args ?? "").trim().toLowerCase();
+	switch (sub) {
+		case "enable":
+			rt.config.enabled = true;
+			saveConfig(rt.config);
+			ctx.ui.notify("antiloop: ON", "info");
+			rt.updateStatus(ctx);
+			return;
+		case "disable":
+			rt.config.enabled = false;
+			saveConfig(rt.config);
+			ctx.ui.notify("antiloop: OFF", "info");
+			rt.updateStatus(ctx);
+			return;
+		case "status":
+			return showStatus(ctx, rt);
+		case "config":
+			return showConfigMenu(ctx, rt);
+		case "log":
+			return showLog(ctx, rt);
+		case "reset":
+			resetState(rt.state);
+			rt.pendingIntervention = null;
+			ctx.ui.notify("antiloop: reset", "info");
+			rt.updateStatus(ctx);
+			return;
+		case "test":
+			return runSelfTest(ctx);
+		default:
+			rt.config.enabled = !rt.config.enabled;
+			saveConfig(rt.config);
+			ctx.ui.notify(`antiloop: ${rt.config.enabled ? "ON" : "OFF"}`, "info");
+			rt.updateStatus(ctx);
+			return;
+	}
+}
+
+async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<void> {
+	const lvl = ["none", "warn", "force", "abort"][rt.state.currentLevel];
+	const recent = rt.state.detections.slice(-5);
+	const lines = [
+		`state: ${rt.config.enabled ? "ON" : "OFF"} · level: ${lvl} · consecutive: ${rt.state.consecutiveDetections}`,
+		`total: ${rt.state.totalDetections} · tracked: ${rt.state.recentMessages.length} · forced: ${rt.state.inForcedBreak ? "yes" : "no"}`,
+		"",
+		"thresholds:",
+		`  warn: ${rt.config.warningThreshold}  force: ${rt.config.forceBreakThreshold}  abort: ${rt.config.abortThreshold || "off"}`,
+		`  similarity: ${(rt.config.similarityThreshold * 100).toFixed(0)}%  window: ${rt.config.detectionWindow}`,
+		`  tool sim: ${(rt.config.toolSimilarityThreshold * 100).toFixed(0)}%  tool repeat: ${rt.config.minToolRepeatCount}+ prior`,
+		`  result sim: ${(rt.config.resultSimilarityThreshold * 100).toFixed(0)}%  (same cmd + diff outcome = no loop)`,
+		"",
+		`detectors: text ${yn(rt.config.detectTextLoops)} · tool ${yn(rt.config.detectToolLoops)} · think ${yn(rt.config.detectThinkingLoops)}`,
+	];
+	if (recent.length) {
+		lines.push("", "recent:");
+		for (const d of recent) lines.push(`  [${d.type}] ${d.description} · ${formatDuration(Date.now() - d.timestamp)} ago`);
+	}
+	ctx.ui.notify(lines.join("\n"), "info");
+}
+
+async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promise<void> {
+	const c = rt.config;
+	const picked = await selectFrom(ctx, "antiloop config", [
+		{ value: "toggle" as const, label: c.enabled ? "🟢 disable" : "🔴 enable", description: "toggle detection" },
+		{ value: "warn" as const, label: `warn threshold: ${c.warningThreshold}` },
+		{ value: "force" as const, label: `force threshold: ${c.forceBreakThreshold}` },
+		{ value: "abort" as const, label: `abort threshold: ${c.abortThreshold || "off"}`, description: "0 = disabled" },
+		{ value: "sim" as const, label: `similarity: ${(c.similarityThreshold * 100).toFixed(0)}%` },
+		{ value: "toolSim" as const, label: `tool similarity: ${(c.toolSimilarityThreshold * 100).toFixed(0)}%`, description: "args must match this closely to count as the same call" },
+		{ value: "toolRepeat" as const, label: `tool repeat: ${c.minToolRepeatCount}+ prior`, description: "recurrences before a tool loop flags" },
+		{ value: "resultSim" as const, label: `result similarity: ${(c.resultSimilarityThreshold * 100).toFixed(0)}%`, description: "same cmd + different outcome vetoes the loop" },
+		{ value: "window" as const, label: `window: ${c.detectionWindow} msgs` },
+		{ value: "text" as const, label: `text detect: ${yn(c.detectTextLoops)}` },
+		{ value: "tool" as const, label: `tool detect: ${yn(c.detectToolLoops)}` },
+		{ value: "think" as const, label: `think detect: ${yn(c.detectThinkingLoops)}` },
+		{ value: "notify" as const, label: `notify: ${yn(c.notifyOnDetection)}` },
+		{ value: "reset" as const, label: "reset state" },
+	]);
+	if (!picked) return;
+	switch (picked) {
+		case "toggle":
+			c.enabled = !c.enabled;
+			saveConfig(c);
+			ctx.ui.notify(`antiloop: ${c.enabled ? "ON" : "OFF"}`, "info");
+			rt.updateStatus(ctx);
+			break;
+		case "warn": {
+			const v = await selectFrom(ctx, "warn threshold", [
+				{ value: 1, label: "1 (sensitive)" },
+				{ value: 2, label: "2 (default)" },
+				{ value: 3, label: "3" },
+				{ value: 5, label: "5 (relaxed)" },
+			]);
+			if (v !== undefined) { c.warningThreshold = v; saveConfig(c); ctx.ui.notify(`warn: ${v}`, "info"); }
+			break;
+		}
+		case "force": {
+			const v = await selectFrom(ctx, "force threshold", [
+				{ value: 2, label: "2 (sensitive)" },
+				{ value: 3, label: "3 (default)" },
+				{ value: 5, label: "5" },
+				{ value: 8, label: "8 (relaxed)" },
+			]);
+			if (v !== undefined) { c.forceBreakThreshold = v; saveConfig(c); ctx.ui.notify(`force: ${v}`, "info"); }
+			break;
+		}
+		case "abort": {
+			const v = await selectFrom(ctx, "abort threshold (0=off)", [
+				{ value: 0, label: "off" },
+				{ value: 5, label: "5" },
+				{ value: 8, label: "8" },
+				{ value: 10, label: "10" },
+				{ value: 15, label: "15" },
+			]);
+			if (v !== undefined) { c.abortThreshold = v; saveConfig(c); ctx.ui.notify(`abort: ${v || "off"}`, "info"); }
+			break;
+		}
+		case "sim": {
+			const v = await selectFrom(ctx, "similarity", [
+				{ value: 0.5, label: "50% (sensitive)" },
+				{ value: 0.6, label: "60%" },
+				{ value: 0.7, label: "70%" },
+				{ value: 0.75, label: "75% (default)" },
+				{ value: 0.8, label: "80%" },
+				{ value: 0.9, label: "90% (relaxed)" },
+			]);
+			if (v !== undefined) { c.similarityThreshold = v; saveConfig(c); ctx.ui.notify(`similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			break;
+		}
+		case "toolSim": {
+			const v = await selectFrom(ctx, "tool similarity (args)", [
+				{ value: 0.99, label: "99% (strict)" },
+				{ value: 0.95, label: "95% (default)" },
+				{ value: 0.9, label: "90%" },
+				{ value: 0.8, label: "80% (sensitive)" },
+			]);
+			if (v !== undefined) { c.toolSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`tool similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			break;
+		}
+		case "toolRepeat": {
+			const v = await selectFrom(ctx, "tool repeat (prior occurrences)", [
+				{ value: 1, label: "1 (sensitive)" },
+				{ value: 2, label: "2 (default)" },
+				{ value: 3, label: "3 (relaxed)" },
+			]);
+			if (v !== undefined) { c.minToolRepeatCount = v; saveConfig(c); ctx.ui.notify(`tool repeat: ${v}+ prior`, "info"); }
+			break;
+		}
+		case "resultSim": {
+			const v = await selectFrom(ctx, "result similarity (outcome veto)", [
+				{ value: 0.95, label: "95% (strict — only near-identical results count as same outcome)" },
+				{ value: 0.8, label: "80% (default)" },
+				{ value: 0.6, label: "60% (relaxed — tolerates more output noise)" },
+			]);
+			if (v !== undefined) { c.resultSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`result similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			break;
+		}
+		case "window": {
+			const v = await selectFrom(ctx, "window", [
+				{ value: 5, label: "5" },
+				{ value: 10, label: "10 (default)" },
+				{ value: 15, label: "15" },
+				{ value: 20, label: "20" },
+			]);
+			if (v !== undefined) { c.detectionWindow = v; saveConfig(c); ctx.ui.notify(`window: ${v}`, "info"); }
+			break;
+		}
+		case "text":
+			c.detectTextLoops = !c.detectTextLoops; saveConfig(c);
+			ctx.ui.notify(`text: ${yn(c.detectTextLoops)}`, "info"); break;
+		case "tool":
+			c.detectToolLoops = !c.detectToolLoops; saveConfig(c);
+			ctx.ui.notify(`tool: ${yn(c.detectToolLoops)}`, "info"); break;
+		case "think":
+			c.detectThinkingLoops = !c.detectThinkingLoops; saveConfig(c);
+			ctx.ui.notify(`think: ${yn(c.detectThinkingLoops)}`, "info"); break;
+		case "notify":
+			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
+			ctx.ui.notify(`notify: ${yn(c.notifyOnDetection)}`, "info"); break;
+		case "reset":
+			resetState(rt.state);
+			rt.pendingIntervention = null;
+			ctx.ui.notify("reset", "info");
+			rt.updateStatus(ctx);
+			break;
+	}
+}
+
+async function showLog(ctx: ExtensionCommandContext, rt: Runtime): Promise<void> {
+	if (!rt.state.detections.length) {
+		ctx.ui.notify("no detections this session", "info");
+		return;
+	}
+	const items = rt.state.detections.slice(-30).reverse().map((d) => ({
+		value: "" as const,
+		label: `[${d.type}] ${d.description}`,
+		description: `${(d.similarity * 100).toFixed(0)}% · ${formatDuration(Date.now() - d.timestamp)} ago`,
+	}));
+	await selectFrom(ctx, `detections (${rt.state.detections.length} total)`, items);
+}
+
+export function resetState(state: AntiloopState): void {
+	state.recentMessages = [];
+	state.detections = [];
+	state.currentLevel = 0;
+	state.consecutiveDetections = 0;
+	state.inForcedBreak = false;
+	state.totalDetections = 0;
+	state.lastDetectedTurnIndex = -1;
+}
+
+async function runSelfTest(ctx: ExtensionCommandContext): Promise<void> {
+	const { runSelfTest } = await import("./detect.ts");
+	ctx.ui.notify(`antiloop self-test\n${runSelfTest().join("\n")}`, "info");
+}
+
+function yn(b: boolean): string {
+	return b ? "on" : "off";
+}

package/src/config.ts

@@ -0,0 +1,49 @@
+// antiloop — config load/save. Lightweight: only file I/O at session_start.
+
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { AntiloopConfig } from "./types.ts";
+
+export const CONFIG_FILE = "antiloop.json";
+
+export const DEFAULT_CONFIG: AntiloopConfig = {
+	enabled: true,
+	warningThreshold: 2,
+	forceBreakThreshold: 3,
+	abortThreshold: 0,
+	similarityThreshold: 0.75,
+	toolSimilarityThreshold: 0.95,
+	minToolRepeatCount: 2,
+	resultSimilarityThreshold: 0.8,
+	detectToolLoops: true,
+	detectThinkingLoops: true,
+	detectTextLoops: true,
+	notifyOnDetection: true,
+	maxHistoryEntries: 100,
+	detectionWindow: 10,
+};
+
+export function getConfigPath(): string {
+	return join(getAgentDir(), CONFIG_FILE);
+}
+
+export function loadConfig(): AntiloopConfig {
+	const p = getConfigPath();
+	if (existsSync(p)) {
+		try {
+			return { ...DEFAULT_CONFIG, ...JSON.parse(readFileSync(p, "utf-8")) };
+		} catch (e) {
+			console.error(`[antiloop] config load error: ${e}`);
+		}
+	}
+	return { ...DEFAULT_CONFIG };
+}
+
+export function saveConfig(config: AntiloopConfig): void {
+	try {
+		writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+	} catch (e) {
+		console.error(`[antiloop] config save error: ${e}`);
+	}
+}