pi-antiloop 1.0.1 → 1.2.0

package/README.md

@@ -6,17 +6,17 @@
 
 # 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
-- **Live status bar** — `🔄 antiloop`, `⚠️ antiloop(N)`, `🛑 antiloop(N)`, `🚨 antiloop(N)` reflect the current intervention level
+- **Live footer indicator** — `🔄 antiloop(on|off)` in the footer, per spec, with the current level (`⚠️/🛑/🚨`) and consecutive count; an interactive TUI footer adds a keyboard toggle (`esc+a` by default, configurable/off) and preserves the built-in footer's pwd/branch/context/model info
 - **Detection log** — timestamped history with similarity scores, filterable through the native pi menu
 - **Self-test** — `/antiloop test` runs built-in cases to verify the similarity engine is calibrated
 - **User input softens detection** — each new user message decays the consecutive counter so a fresh prompt can resolve the loop without manual reset
@@ -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.
 
@@ -155,7 +161,7 @@ Each detected pair becomes a `LoopDetection { type, similarity, messageIndices,
 | Level | Trigger | Behavior |
 |-------|---------|----------|
 | 0 (no loop) | — | Silent — passes the message through |
-| 1 (warning) | `consecutiveDetections >= warningThreshold` | Injects a soft reminder asking the model to vary its approach |
+| 1 (warning) | `consecutiveDetections >= warningThreshold` | Notifies the user (`⚠️`) — no message is injected into the conversation, so the model's generation is never interrupted by the warning itself |
 | 2 (force break) | `consecutiveDetections >= forceBreakThreshold` | Injects mandatory anti-loop instructions + appends a context message to the last assistant message |
 | 3 (abort) | `consecutiveDetections >= abortThreshold` | (Disabled by default) Surfaces an error asking the user for new instructions |
 
@@ -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,12 +223,17 @@ 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,
   "notifyOnDetection": true,
   "maxHistoryEntries": 100,
-  "detectionWindow": 10
+  "detectionWindow": 10,
+  "interactiveFooter": true,
+  "toggleShortcut": "esc+a"
 }
 ```
 
@@ -208,22 +243,28 @@ 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 |
 | `notifyOnDetection` | `true` | Show a notification on every detection |
 | `maxHistoryEntries` | `100` | Max detection history entries |
 | `detectionWindow` | `10` | Number of recent messages to analyze |
+| `interactiveFooter` | `true` | TUI footer replaces the built-in one with an antiloop indicator + toggle shortcut (set `false` to keep the built-in footer and only the `setStatus` line) |
+| `toggleShortcut` | `esc+a` | Key sequence that toggles antiloop from the footer (`esc+a` or `off`). The input is never consumed, so typing is unaffected |
 
 ## 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
 
@@ -236,16 +277,21 @@ antiloop/
 │   ├── 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)
+- **TUI integration** — uses `ctx.ui.select` for the config menu and the log viewer; `ctx.ui.notify` for state notifications; `ctx.ui.setStatus` + a custom `ctx.ui.setFooter` component for the persistent footer indicator, live level info, and the `esc+a` keyboard toggle (`ctx.ui.onTerminalInput`, never consumes input)
+- **Hooks** — `message_end` (track messages + tool call ids), `turn_end` (attach result fingerprints + detect), `input` (decay), `before_agent_start` (inject intervention — force/abort only), `context` (modify context in force-break mode), `session_start` (load config + install footer + reset), `session_shutdown` (restore built-in footer)
 
 ## License
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-antiloop",
-  "version": "1.0.1",
-  "description": "Antiloop: detect reasoning loops and force a break (warn → force → abort) across text, tool, thinking, and structural patterns.",
+  "version": "1.2.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",
     "antiloop",

package/src/commands.ts

@@ -57,8 +57,11 @@ async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<vo
 		"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)}`,
+		`footer: interactive ${yn(rt.config.interactiveFooter)} · toggle: ${rt.config.toggleShortcut}`,
 	];
 	if (recent.length) {
 		lines.push("", "recent:");
@@ -75,11 +78,16 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 		{ 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: "footer" as const, label: `interactive footer: ${yn(c.interactiveFooter)}`, description: "TUI footer with toggle shortcut" },
+		{ value: "shortcut" as const, label: `toggle shortcut: ${c.toggleShortcut}`, description: "esc+a or off" },
 		{ value: "reset" as const, label: "reset state" },
 	]);
 	if (!picked) return;
@@ -133,6 +141,34 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 			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" },
@@ -155,6 +191,20 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 		case "notify":
 			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
 			ctx.ui.notify(`notify: ${yn(c.notifyOnDetection)}`, "info"); break;
+		case "footer":
+			c.interactiveFooter = !c.interactiveFooter; saveConfig(c);
+			ctx.ui.notify(`interactive footer: ${yn(c.interactiveFooter)}`, "info");
+			rt.refreshFooter?.(ctx);
+			rt.updateStatus(ctx);
+			break;
+		case "shortcut": {
+			const v = await selectFrom(ctx, "toggle shortcut", [
+				{ value: "esc+a" as const, label: "esc+a (default)", description: "press ESC then a to toggle" },
+				{ value: "off" as const, label: "off", description: "disable keyboard toggle" },
+			]);
+			if (v !== undefined) { c.toggleShortcut = v; saveConfig(c); rt.refreshFooter?.(ctx); ctx.ui.notify(`toggle shortcut: ${v}`, "info"); }
+			break;
+		}
 		case "reset":
 			resetState(rt.state);
 			rt.pendingIntervention = null;
@@ -184,31 +234,12 @@ export function resetState(state: AntiloopState): void {
 	state.consecutiveDetections = 0;
 	state.inForcedBreak = false;
 	state.totalDetections = 0;
+	state.lastDetectedTurnIndex = -1;
 }
 
 async function runSelfTest(ctx: ExtensionCommandContext): Promise<void> {
-	// Inline similarity + normalize (mirrors detect.ts). Keeps test self-contained
-	// without re-importing private helpers.
-	const norm = (t: string) => t.toLowerCase().replace(/\s+/g, " ").replace(/[^\w\s]/g, "").trim();
-	const cases: Array<{ a: string; b: string; expect: string }> = [
-		{ a: "Hello world", b: "Hello world", expect: "1.00" },
-		{ a: "Hello world", b: "Hello World!", expect: "high" },
-		{ a: "The quick brown fox", b: "The quick brown fox jumps over the lazy dog", expect: "high" },
-		{ a: "Hello world", b: "Goodbye universe", expect: "low" },
-		{ a: "I will read the file first", b: "I will read the file first to understand", expect: "high" },
-	];
-	const out: string[] = [];
-	for (const c of cases) {
-		// Re-implement minimal Levenshtein similarity for the self-test
-		const a = norm(c.a), b = norm(c.b);
-		const max = Math.max(a.length, b.length);
-		let diff = 0;
-		for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) diff++;
-		diff += Math.abs(a.length - b.length);
-		const s = max ? 1 - diff / max : 1;
-		out.push(`"${c.a}" vs "${c.b}" → ${(s * 100).toFixed(0)}% (exp: ${c.expect})`);
-	}
-	ctx.ui.notify(`antiloop self-test\n${out.join("\n")}`, "info");
+	const { runSelfTest } = await import("./detect.ts");
+	ctx.ui.notify(`antiloop self-test\n${runSelfTest().join("\n")}`, "info");
 }
 
 function yn(b: boolean): string {

package/src/config.ts

@@ -13,12 +13,17 @@ export const DEFAULT_CONFIG: AntiloopConfig = {
 	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,
+	interactiveFooter: true,
+	toggleShortcut: "esc+a",
 };
 
 export function getConfigPath(): string {

package/src/detect.ts

@@ -1,6 +1,6 @@
 // antiloop — similarity + detection engine. Lazy-loaded on first message_end.
 
-import type { AntiloopConfig, AntiloopState, LoopDetection } from "./types.ts";
+import type { AntiloopConfig, AntiloopState, LoopDetection, TrackedToolCall } from "./types.ts";
 
 const MIN_CONTENT_LENGTH = 50;
 
@@ -53,15 +53,57 @@ function similarity(a: string, b: string): number {
 	return inter / uni;
 }
 
+/**
+ * Normalized, size-capped tail of a tool result, prefixed with ok/err so a
+ * change between success and failure is always a "different outcome".
+ * Stable against PID / timestamp noise at the tail of command output.
+ */
+export function resultFingerprint(
+	parts: Array<{ type: string; text?: string }>,
+	isError: boolean,
+): string | undefined {
+	let text = "";
+	for (const p of parts) if (p.type === "text" && typeof p.text === "string") text += p.text;
+	const norm = normalizeText(text);
+	if (!norm.length) return undefined;
+	return `${isError ? "err" : "ok"}|${norm.slice(-400)}`;
+}
+
+/** Same outcome = identical fingerprint, or high similarity of the tails. */
+function sameOutcome(a: string, b: string, threshold: number): boolean {
+	if (a === b) return true;
+	// Fingerprints are already normalized + capped, so short ones can be
+	// compared with edit distance directly — similarity() bails under 50 chars
+	// and would wrongly veto small outputs with harmless noise (PIDs, times).
+	if (a.length < 100 && b.length < 100) {
+		const max = Math.max(a.length, b.length);
+		const s = max ? 1 - levenshtein(a, b) / max : 1;
+		return s >= threshold;
+	}
+	const s = similarity(a, b);
+	return s >= threshold && s > 0;
+}
+
 function toolCallsSimilar(
-	c1: Array<{ name: string; args: string }>,
-	c2: Array<{ name: string; args: string }>,
+	c1: TrackedToolCall[],
+	c2: TrackedToolCall[],
+	threshold: number,
+	resultThreshold: number,
 ): boolean {
 	if (c1.length !== c2.length) return false;
-	if (!c1.length) return true;
+	// Empty call lists carry no repetition evidence — never treat them as a match.
+	if (!c1.length) return false;
 	for (let i = 0; i < c1.length; i++) {
 		if (c1[i].name !== c2[i].name) return false;
-		if (similarity(c1[i].args, c2[i].args) < 0.8) return false;
+		if (similarity(c1[i].args, c2[i].args) < threshold) return false;
+		// Result veto: the same command producing a different outcome is
+		// progress (a retry that fixed the problem), not a loop. Only applies
+		// when both runs actually captured a result.
+		const r1 = c1[i].result;
+		const r2 = c2[i].result;
+		if (r1 && r2 && !sameOutcome(r1, r2, resultThreshold)) {
+			return false;
+		}
 	}
 	return true;
 }
@@ -98,7 +140,7 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 				const last = opens[opens.length - 1].o;
 				let n = 0;
 				for (let i = 0; i < opens.length - 1; i++) {
-					if (similarity(last, opens[i].o) > 0.8) n++;
+					if (similarity(last, opens[i].o) > 0.9) n++;
 				}
 				if (n >= 2) {
 					out.push({
@@ -117,18 +159,25 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 		const last = win[win.length - 1];
 		const lastCalls = last.toolCalls;
 		if (lastCalls && lastCalls.length) {
+			const matched: number[] = [];
 			for (let i = 0; i < win.length - 1; i++) {
 				const prev = win[i].toolCalls;
-				if (prev && toolCallsSimilar(lastCalls, prev)) {
-					out.push({
-						type: "tool",
-						similarity: 1,
-						messageIndices: [start + i, msgs.length - 1],
-						description: `repeated: ${lastCalls.map((t) => t.name).join(", ")}`,
-						timestamp: now,
-					});
+				if (prev && toolCallsSimilar(lastCalls, prev, config.toolSimilarityThreshold, config.resultSimilarityThreshold)) {
+					matched.push(start + i);
 				}
 			}
+			// A single overlapping command (shared scaffolding in a long bash
+			// call) is NOT a loop — the same call set must recur at least
+			// minToolRepeatCount times inside the window before we flag it.
+			if (matched.length >= config.minToolRepeatCount) {
+				out.push({
+					type: "tool",
+					similarity: 1,
+					messageIndices: [...matched, msgs.length - 1],
+					description: `repeated ${matched.length + 1}x: ${lastCalls.map((t) => t.name).join(", ")}`,
+					timestamp: now,
+				});
+			}
 		}
 	}
 
@@ -165,3 +214,67 @@ export function interventionMessage(level: 1 | 2 | 3, detections: LoopDetection[
 	}
 	return `[antiloop] 🚨 persistent loop\n${det}\nunable to break automatically — provide new instructions.`;
 }
+
+// ---------------------------------------------------------------------------
+// Self-test — runs the REAL engine so it tracks future calibration changes.
+// Includes the regression case that motivated the 0.95 tool threshold:
+// sequential bash operations that share scaffolding (env setup, model path,
+// most flags) are NOT a loop, even when they score 0.8–0.94 similar.
+// ---------------------------------------------------------------------------
+
+export function runSelfTest(): string[] {
+	const out: string[] = [];
+	const pct = (s: number) => `${(s * 100).toFixed(0)}%`;
+
+	// --- text similarity ---
+	const textSame = "I will read the file first to understand the structure before editing anything at all";
+	const textNear = "I will read the file first to understand the layout before editing anything at all";
+	const textDiff = "The quick brown fox jumps over the lazy dog near the river bank and keeps running";
+	const s1 = similarity(textSame, textSame);
+	const s2 = similarity(textSame, textNear);
+	const s3 = similarity(textSame, textDiff);
+	out.push(`text identical      → ${pct(s1)} (exp 100%) ${s1 >= 0.99 ? "✅" : "❌"}`);
+	out.push(`text near-identical → ${pct(s2)} (exp ≥ 80%) ${s2 >= 0.8 ? "✅" : "❌"}`);
+	out.push(`text unrelated      → ${pct(s3)} (exp < 50%) ${s3 < 0.5 ? "✅" : "❌"}`);
+
+	// --- tool calls (default thresholds: 95% args similarity, 2 prior repeats) ---
+	const common =
+		"cd /home/j/llm && ulimit -l unlimited 2>/dev/null; export ROCBLAS_USE_HIPBLASLT=1 HIP_VISIBLE_DEVICES=1; " +
+		"setsid ./kingjones30-boosted/build-unroll/bin/llama-server " +
+		"-m /home/j/llm/ling-rocmfp4/Ling-3.0-flash-ROCmFP4-STRIX-MTP-Q4_0-00001-of-00002.gguf " +
+		"-dev ROCm0 -ngl 999 -fa on -c 8192 -fit off -np 1 -sm row -ub 2048 " +
+		"--spec-type draft-mtp --spec-draft-n-max 2 --spec-draft-n-min 0 --spec-draft-p-min 0.4 " +
+		"--reasoning off --jinja --host 127.0.0.1 --port 8093 --no-webui";
+	const sweepRun1 = `${common} -b 2048 -ctk q8_0 -ctv turbo4 > /tmp/sweep-turbo4.log 2>&1 & echo $!; sleep 60; grep "model loaded" /tmp/sweep-turbo4.log`;
+	const sweepRun2 = `${common} -b 8192 -ctk f16 -ctv f16 > /tmp/sweep-b8192.log 2>&1 & echo $!; sleep 70; grep "model loaded" /tmp/sweep-b8192.log`;
+
+	const t1 = toolCallsSimilar([{ name: "bash", args: sweepRun1 }], [{ name: "bash", args: sweepRun1 }], 0.95, 0.8);
+	const t2 = toolCallsSimilar([{ name: "bash", args: sweepRun1 }], [{ name: "bash", args: sweepRun2 }], 0.95, 0.8);
+	const t2old = toolCallsSimilar([{ name: "bash", args: sweepRun1 }], [{ name: "bash", args: sweepRun2 }], 0.8, 0.8);
+	const t3 = toolCallsSimilar([{ name: "bash", args: sweepRun1 }], [{ name: "read", args: "{}" }], 0.95, 0.8);
+	const t4 = toolCallsSimilar([], [], 0.95, 0.8);
+	out.push(`tool identical cmd  → ${t1 ? "match" : "no match"} (exp match) ${t1 ? "✅" : "❌"}`);
+	out.push(`tool sweep (flags)  → ${t2 ? "match" : "no match"} @95% (exp no match) ${!t2 ? "✅" : "❌"}`);
+	out.push(`tool sweep (old 80%)→ ${t2old ? "match" : "no match"} @80% (exp match — was the false positive) ${t2old ? "✅" : "❌"}`);
+	out.push(`tool different tool → ${t3 ? "match" : "no match"} (exp no match) ${!t3 ? "✅" : "❌"}`);
+	out.push(`tool empty lists    → ${t4 ? "match" : "no match"} (exp no match) ${!t4 ? "✅" : "❌"}`);
+
+	// --- result veto: same command, different outcome = progress, not a loop ---
+	const rErr = resultFingerprint([{ type: "text", text: "error: invalid argument: ROCm0\nPID 74970" }], true)!;
+	const rErr2 = resultFingerprint([{ type: "text", text: "error: invalid argument: ROCm0\nPID 77788" }], true)!;
+	const rOk = resultFingerprint([{ type: "text", text: "model loaded\nserver is listening on http://127.0.0.1:8093" }], false)!;
+	const sameCmdSameOut = toolCallsSimilar(
+		[{ name: "bash", args: sweepRun1, result: rErr }],
+		[{ name: "bash", args: sweepRun1, result: rErr2 }],
+		0.95, 0.8,
+	);
+	const sameCmdDiffOut = toolCallsSimilar(
+		[{ name: "bash", args: sweepRun1, result: rErr }],
+		[{ name: "bash", args: sweepRun1, result: rOk }],
+		0.95, 0.8,
+	);
+	out.push(`result same outcome  → ${sameCmdSameOut ? "match" : "no match"} (exp match — PID noise ok) ${sameCmdSameOut ? "✅" : "❌"}`);
+	out.push(`result diff outcome  → ${sameCmdDiffOut ? "match" : "no match"} (exp no match — error→success is progress) ${!sameCmdDiffOut ? "✅" : "❌"}`);
+
+	return out;
+}

package/src/index.ts

@@ -1,14 +1,16 @@
 /**
  * antiloop — detect reasoning loops and intervene.
- * Hooks: message_end, input, before_agent_start, context, turn_end, session_start.
+ * Hooks: message_end, input, before_agent_start, context, turn_end, session_start, session_shutdown.
  * Commands: /antiloop [enable|disable|status|config|log|reset|test]
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { loadConfig } from "./config.ts";
-import type { AntiloopState, LoopDetection, Runtime } from "./types.ts";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { loadConfig, saveConfig } from "./config.ts";
+import type { AntiloopState, LoopDetection, Runtime, TrackedToolCall } from "./types.ts";
 
 const ICONS = ["", "⚠️", "🛑", "🚨"] as const;
+const LEVEL_NAMES = ["", "warning", "force", "abort"] as const;
 
 function newState(): AntiloopState {
 	return {
@@ -19,25 +21,54 @@ function newState(): AntiloopState {
 		inForcedBreak: false,
 		totalDetections: 0,
 		lastUserMessageTime: 0,
+		lastDetectedTurnIndex: -1,
 	};
 }
 
+/** Compact pwd: ~-relative when inside $HOME, with trailing separator trimmed. */
+function formatCwd(cwd: string): string {
+	const home = process.env.HOME;
+	if (home && cwd.startsWith(home)) {
+		const rel = cwd.slice(home.length).replace(/^[/\\]+/, "");
+		return rel ? `~/${rel}` : "~";
+	}
+	return cwd;
+}
+
 export default function antiloopExtension(pi: ExtensionAPI) {
 	const config = loadConfig();
 	let state = newState();
 
+	/** TUI handle for forcing footer re-renders (set by the footer factory). */
+	let activeTui: { requestRender(force?: boolean): void } | undefined;
+
+	/** Status text shown in the footer: "(emoji_antiloop)(on/off)" per spec. */
+	function antiloopStatusText(): string {
+		if (!config.enabled) return "🔄 antiloop(off)";
+		if (state.currentLevel === 0) return "🔄 antiloop(on)";
+		return `${ICONS[state.currentLevel]} antiloop(on)×${state.consecutiveDetections}`;
+	}
+
 	function updateStatus(ctx: ExtensionContext): void {
-		if (!config.enabled) ctx.ui.setStatus("antiloop", undefined);
-		else if (state.currentLevel === 0) ctx.ui.setStatus("antiloop", "🔄 antiloop");
-		else ctx.ui.setStatus("antiloop", `${ICONS[state.currentLevel]} antiloop(${state.consecutiveDetections})`);
+		// Always set a status line so the footer shows on/off either way.
+		ctx.ui.setStatus("antiloop", antiloopStatusText());
+		activeTui?.requestRender();
 	}
 
-	const rt: Runtime = { config, state, pendingIntervention: null, updateStatus };
+	const rt: Runtime = { config, state, pendingIntervention: null, updateStatus, refreshFooter: installFooter };
 	const setPending = (v: string | null) => { rt.pendingIntervention = v; };
 
+	/** Toggle enable/disable, persisting config and refreshing the footer. */
+	function toggleEnabled(ctx: ExtensionContext): void {
+		config.enabled = !config.enabled;
+		saveConfig(config);
+		ctx.ui.notify(`antiloop: ${config.enabled ? "ON" : "OFF"}`, "info");
+		updateStatus(ctx);
+	}
+
 	function processDetections(
 		detections: LoopDetection[],
-		interventionMessage: (level: 1 | 2 | 3, d: LoopDetection[]) => string,
+		interventionMessage: (level: 2 | 3, d: LoopDetection[]) => string,
 	): void {
 		if (!detections.length) {
 			if (state.consecutiveDetections > 0) state.consecutiveDetections = Math.max(0, state.consecutiveDetections - 1);
@@ -58,19 +89,114 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		else if (state.consecutiveDetections >= config.warningThreshold) next = 1;
 		if (next > state.currentLevel) state.currentLevel = next;
 
-		if (state.currentLevel > 0) {
-			setPending(interventionMessage(state.currentLevel as 1 | 2 | 3, detections));
-			state.inForcedBreak = state.currentLevel >= 2;
+		// Warning (level 1) is informational only: notify the user but DO NOT
+		// inject any message into the conversation. Injecting at warning level
+		// made the model respond to the warning, which could stall generation
+		// even though hard-kill turns remained. Only force (2) / abort (3) inject.
+		if (state.currentLevel >= 2) {
+			setPending(interventionMessage(state.currentLevel as 2 | 3, detections));
+			state.inForcedBreak = true;
+		} else if (state.currentLevel === 1) {
+			state.inForcedBreak = false;
 		}
 	}
 
-	pi.on("message_end", async (event, ctx) => {
+	// ------------------------------------------------------------------
+	// Interactive footer (TUI). Replaces the built-in footer with a line
+	// per spec — "🔄 antiloop(on|off)" — plus live detection info, a
+	// keyboard toggle (esc+a by default, configurable/off), and the
+	// built-in footer's useful data (pwd, branch, ctx %, model) preserved.
+	// ------------------------------------------------------------------
+	function installFooter(ctx: ExtensionContext): void {
+		if (!config.interactiveFooter || ctx.mode !== "tui") {
+			ctx.ui.setFooter(undefined);
+			return;
+		}
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			activeTui = tui;
+
+			// Keyboard toggle from raw terminal input: escape followed by `a`.
+			// We never consume the input, so typing is unaffected — ESC alone
+			// passes through, and an accidental toggle is easily reversed.
+			let pendingEsc = false;
+			const shortcut = config.toggleShortcut;
+			const unsubInput =
+				shortcut === "off"
+					? undefined
+					: ctx.ui.onTerminalInput?.((data: string) => {
+							if (config.toggleShortcut === "off") return undefined;
+							if (data === "\x1b") {
+								pendingEsc = true;
+								return undefined;
+							}
+							if (pendingEsc && data === "a") {
+								pendingEsc = false;
+								toggleEnabled(ctx);
+								return undefined;
+							}
+							pendingEsc = false;
+							return undefined;
+					  });
+
+			return {
+				dispose() {
+					unsubInput?.();
+					if (activeTui === tui) activeTui = undefined;
+				},
+				invalidate() {},
+				render(width: number): string[] {
+					const lines: string[] = [];
+
+					// Line 1: the spec indicator + toggle hint.
+					const status = antiloopStatusText();
+					const colored = config.enabled ? theme.fg("accent", status) : theme.fg("dim", status);
+					const hint =
+						config.toggleShortcut !== "off"
+							? theme.fg("dim", `  [${config.toggleShortcut}] toggle`)
+							: theme.fg("dim", "  [/antiloop] toggle");
+					lines.push(truncateToWidth(colored + hint, width));
+
+					// Line 2 (only while detecting): level + consecutive + last reason.
+					if (state.currentLevel > 0) {
+						const last = state.detections[state.detections.length - 1];
+						const desc = last ? ` · ${last.description}` : "";
+						lines.push(
+							truncateToWidth(
+								theme.fg("warning", `${LEVEL_NAMES[state.currentLevel]} ×${state.consecutiveDetections}${desc}`),
+								width,
+							),
+						);
+					}
+
+					// Line 3: built-in footer data preserved (dim).
+					let info = formatCwd(ctx.cwd);
+					const branch = footerData.getGitBranch();
+					if (branch) info += ` (${branch})`;
+					const usage = ctx.getContextUsage();
+					const cw = usage?.contextWindow ?? ctx.model?.contextWindow;
+					if (cw && usage && usage.percent !== null) info += ` · ctx ${Math.round(usage.percent)}%`;
+					if (ctx.model) info += ` · ${ctx.model.id}`;
+					lines.push(truncateToWidth(theme.fg("dim", info), width));
+
+					// Line 4 (only when other extensions set statuses): keep them visible.
+					const others = Array.from(footerData.getExtensionStatuses().entries())
+						.filter(([k]) => k !== "antiloop")
+						.map(([, v]) => v);
+					if (others.length) {
+						lines.push(truncateToWidth(theme.fg("dim", others.join("  ")), width));
+					}
+
+					return lines;
+				},
+			};
+		});
+	}
+
+	pi.on("message_end", async (event) => {
 		if (!config.enabled) return;
 		const msg = event.message;
 		if (msg.role !== "assistant") return;
 
-		const { detectLoops, interventionMessage } = await import("./detect.ts");
-
 		let content = "";
 		let thinking = "";
 		if (typeof msg.content === "string") content = msg.content;
@@ -81,10 +207,11 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 			}
 		}
 
-		const toolCalls: Array<{ name: string; args: string }> = [];
+		// Track the call with its id so turn_end can attach the execution result.
+		const toolCalls: TrackedToolCall[] = [];
 		if (Array.isArray(msg.content)) {
 			for (const p of msg.content) {
-				if (p.type === "toolCall") toolCalls.push({ name: p.name, args: JSON.stringify(p.arguments ?? {}) });
+				if (p.type === "toolCall") toolCalls.push({ name: p.name, args: JSON.stringify(p.arguments ?? {}), id: p.id });
 			}
 		}
 
@@ -100,14 +227,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		if (state.recentMessages.length > config.detectionWindow + 5) {
 			state.recentMessages = state.recentMessages.slice(-(config.detectionWindow + 5));
 		}
-
-		const detections = detectLoops(state, config);
-		processDetections(detections, interventionMessage);
-
-		if (config.notifyOnDetection && detections.length && state.currentLevel > 0) {
-			const lvl = ["", "warning", "force", "abort"][state.currentLevel];
-			ctx.ui.notify(`antiloop: ${lvl} — ${detections[0].description}`, state.currentLevel >= 2 ? "error" : "warning");
-		}
 	});
 
 	pi.on("input", async () => {
@@ -145,8 +264,42 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		return { messages: msgs };
 	});
 
-	pi.on("turn_end", async (_e, ctx) => {
-		if (config.enabled) updateStatus(ctx);
+	pi.on("turn_end", async (event, ctx) => {
+		if (!config.enabled) return;
+		const { detectLoops, interventionMessage, resultFingerprint } = await import("./detect.ts");
+
+		const last = state.recentMessages[state.recentMessages.length - 1];
+		// A turn whose assistant message wasn't tracked (short text, no tools)
+		// must not re-run detection on the previous message — skip it.
+		if (!last || last.turnIndex === state.lastDetectedTurnIndex) {
+			updateStatus(ctx);
+			return;
+		}
+		state.lastDetectedTurnIndex = last.turnIndex;
+
+		// Attach execution results to the message that just finished its turn.
+		// Detection runs here (not at message_end) because the results — the
+		// signal that distinguishes "stuck loop" from "making progress" — only
+		// exist after the tools have executed.
+		if (last.toolCalls?.length && event.toolResults.length) {
+			const byId = new Map<string, string | undefined>();
+			for (const tr of event.toolResults) byId.set(tr.toolCallId, resultFingerprint(tr.content, tr.isError));
+			for (const tc of last.toolCalls) {
+				if (tc.id && tc.result === undefined) {
+					const r = byId.get(tc.id);
+					if (r !== undefined) tc.result = r;
+				}
+			}
+		}
+
+		const detections = detectLoops(state, config);
+		processDetections(detections, interventionMessage);
+
+		if (config.notifyOnDetection && detections.length && state.currentLevel > 0) {
+			const lvl = ["", "warning", "force", "abort"][state.currentLevel];
+			ctx.ui.notify(`antiloop: ${lvl} — ${detections[0].description}`, state.currentLevel >= 2 ? "error" : "warning");
+		}
+		updateStatus(ctx);
 	});
 
 	pi.on("session_start", async (_e, ctx) => {
@@ -154,9 +307,17 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		Object.assign(config, loadConfig());
 		state = newState();
 		rt.pendingIntervention = null;
+		installFooter(ctx);
 		updateStatus(ctx);
 	});
 
+	pi.on("session_shutdown", async (_e, ctx) => {
+		// Restore the built-in footer on shutdown (in case another extension
+		// installs its own footer later, or the TUI is torn down).
+		ctx.ui.setFooter(undefined);
+		activeTui = undefined;
+	});
+
 	pi.registerCommand("antiloop", {
 		description: "antiloop: detect & break reasoning loops",
 		getArgumentCompletions: (prefix: string) => {
@@ -169,5 +330,3 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		},
 	});
 }
-
-

package/src/types.ts

@@ -7,12 +7,41 @@ export interface AntiloopConfig {
 	forceBreakThreshold: number;
 	abortThreshold: number;
 	similarityThreshold: number;
+	/**
+	 * How close tool-call arguments must be (0..1) to count as the SAME call.
+	 * High by default: long bash commands share scaffolding (env setup, flags,
+	 * paths) even when they are different operations — a parameter sweep or a
+	 * retry after a fix is NOT a loop. Only near-identical repeats qualify.
+	 */
+	toolSimilarityThreshold: number;
+	/**
+	 * How many PRIOR occurrences of a near-identical tool-call set must exist
+	 * in the window before a tool loop is flagged. 2 = the same call seen 3x.
+	 */
+	minToolRepeatCount: number;
+	/**
+	 * Result-aware veto: when both runs have a captured result, the normalized
+	 * result tails must be at least this similar for the pair to count as a
+	 * loop. Same command + different outcome = progress, not a loop.
+	 */
+	resultSimilarityThreshold: number;
 	detectToolLoops: boolean;
 	detectThinkingLoops: boolean;
 	detectTextLoops: boolean;
 	notifyOnDetection: boolean;
 	maxHistoryEntries: number;
 	detectionWindow: number;
+	/**
+	 * Show the antiloop indicator as a custom interactive footer in TUI mode
+	 * (replaces the built-in footer). When false, the indicator is still shown
+	 * as a status line in the built-in footer via ctx.ui.setStatus.
+	 */
+	interactiveFooter: boolean;
+	/**
+	 * Key sequence that toggles antiloop from the footer (raw terminal input).
+	 * Format: "esc+a" (escape followed by `a`) or "off" to disable.
+	 */
+	toggleShortcut: string;
 }
 
 export type LoopKind = "text" | "tool" | "thinking" | "structural";
@@ -25,10 +54,23 @@ export interface LoopDetection {
 	timestamp: number;
 }
 
+export interface TrackedToolCall {
+	name: string;
+	args: string;
+	/** toolCallId — used to attach the execution result at turn_end. */
+	id?: string;
+	/**
+	 * Normalized tail of the tool result ("err|" / "ok|" prefix + last chars).
+	 * Only set when the turn completed and a result was captured. When both
+	 * sides of a comparison have one, a mismatch vetoes the loop.
+	 */
+	result?: string;
+}
+
 export interface TrackedMessage {
 	content: string;
 	thinking?: string;
-	toolCalls?: Array<{ name: string; args: string }>;
+	toolCalls?: TrackedToolCall[];
 	timestamp: number;
 	turnIndex: number;
 }
@@ -41,6 +83,8 @@ export interface AntiloopState {
 	inForcedBreak: boolean;
 	totalDetections: number;
 	lastUserMessageTime: number;
+	/** turnIndex of the last tracked message detection already ran on. */
+	lastDetectedTurnIndex: number;
 }
 
 export interface Runtime {
@@ -48,4 +92,6 @@ export interface Runtime {
 	state: AntiloopState;
 	pendingIntervention: string | null;
 	updateStatus(ctx: ExtensionContext): void;
+	/** Re-install the interactive footer (after config changes). */
+	refreshFooter?(ctx: ExtensionContext): void;
 }