pi-antiloop 1.1.0 → 1.3.0

package/README.md

@@ -13,10 +13,11 @@
 ## Features
 
 - **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
+- **Task-stream recognition (batch work)** — when another extension (e.g. `punched` appending lines to pi.md, or `plan` adding tasks) makes the model call the *same* tool many times with *different* content, antiloop recognizes it as N distinct tasks of one type and stays silent — no warning, no force break. A genuine loop (the *same* call repeated verbatim) is still caught
 - **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
@@ -115,6 +116,9 @@ Interactive menu with current values:
 - **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)
+- **Task streams** — on/off — recognize homogeneous batch work (same extension tool, distinct content) as N tasks of one type, not a loop
+- **Stream min calls** — `2 / 3 / 4 / 5` — same-tool calls required inside the window before batch recognition kicks in (default 3)
+- **Stream twin threshold** — `99% / 95% / 90%` — arguments this similar count as the *same task*; a twin invalidates the stream and re-enables normal detection (default 99%)
 - **Detection window** — `5 / 10 / 15 / 20` — number of recent messages to analyze
 - **Per-strategy toggles** — text / tool / thinking detection
 - **Notifications** — show detection notifications
@@ -139,6 +143,11 @@ 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) ✅
+batch stream detected  → punched_log×3 (exp punched_log×3) ✅   ← task streams: N tasks of one type
+batch no detections    → silent (exp silent — 98.9% args would match without gate) ✅
+loop still detected     → tool (exp tool — identical repeats are NOT a stream) ✅
+loop survives batch gate→ tool (exp tool — bash repeats are real) ✅
+stream needs ≥3 calls   → no stream (exp no stream at 2 calls) ✅
 ```
 
 ## How It Works
@@ -153,6 +162,7 @@ After every assistant `message_end` event, antiloop extracts the new content (te
 | 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 ≥ 90% across ≥ 3 messages |
+| Task stream | Same tool, many calls | When a tool appears ≥ `taskStreamMinCalls` times (default 3) in the window and *no two* calls are near-identical (`taskStreamTwinThreshold`, default 99%), the tool is an active batch: N different tasks of one type (e.g. `punched_log` appends, `plan_manager` task adds). Those calls are exempt from tool-loop detection, and text/thinking/structural patterns that only involve those batch messages are suppressed too. If even one call pair is a twin (the same task repeated), the tool is *not* a stream and detection proceeds normally |
 
 Each detected pair becomes a `LoopDetection { type, similarity, messageIndices, description }` and the consecutive counter increases.
 
@@ -161,7 +171,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 |
 
@@ -206,6 +216,40 @@ If the same command produced a *different* outcome, the pair is progress:
 
 Results only veto; they never trigger on their own, and calls without a
 captured result fall back to argument matching alone.
+
+### Task streams: N tasks of one type ≠ a loop
+
+Extensions push homogeneous work into the model's hands. `punched` appends
+lines to pi.md one at a time; `plan` adds tasks one at a time; `obsidian_*`
+writes/edits notes file by file. Each call is a *different* task — "add line 1",
+"add line 2", "add line 3" — of the *same type*, and the narration around it
+sounds similar ("now appending the next entry…"). That is not a reasoning
+loop; flagging it would interrupt legitimate multi-step work.
+
+Antiloop recognizes this as a **task stream**: if the same tool name appears at
+least `taskStreamMinCalls` times (default 3) inside the detection window and
+no two calls are "twins" (arguments ≥ `taskStreamTwinThreshold` similar,
+default 99% — any real content difference counts as a distinct task), the
+tool is treated as an active batch:
+
+- tool-loop detection skips messages whose calls are all stream tools;
+- text / thinking / structural detections that only involve those batch
+  messages are suppressed (identical narration while adding N entries is
+  expected, not looping);
+- the footer shows it: `🔄 antiloop(on) · batch: punched_log×4`.
+
+Crucially, the exemption requires **no twins**: the moment the same call
+repeats verbatim (or near-verbatim), the stream is invalid and normal loop
+detection takes over — so a model stuck re-logging the *same* line still gets
+caught. The check is name-agnostic: any extension tool used as a batch is
+covered, no allow-list needed. If a genuine loop coexists with a batch (e.g.
+the same `bash` command re-run while appending different notes), the loop is
+still flagged.
+
+Tunables: `detectTaskStreams` (master switch), `taskStreamMinCalls` (batch
+size needed before recognition), `taskStreamTwinThreshold` (how similar args
+must be to count as *the same task* — lower it to treat near-duplicate
+entries as loops again).
 ```
 
 ### Sliding window
@@ -226,12 +270,17 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
   "toolSimilarityThreshold": 0.95,
   "minToolRepeatCount": 2,
   "resultSimilarityThreshold": 0.8,
+  "detectTaskStreams": true,
+  "taskStreamMinCalls": 3,
+  "taskStreamTwinThreshold": 0.99,
   "detectToolLoops": true,
   "detectThinkingLoops": true,
   "detectTextLoops": true,
   "notifyOnDetection": true,
   "maxHistoryEntries": 100,
-  "detectionWindow": 10
+  "detectionWindow": 10,
+  "interactiveFooter": true,
+  "toggleShortcut": "esc+a"
 }
 ```
 
@@ -245,12 +294,17 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
 | `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 |
+| `detectTaskStreams` | `true` | Recognize homogeneous batch work (same tool called with distinct content — e.g. punched/plan/obsidian extensions) and stay silent; see [task streams](#task-streams-n-tasks-of-one-type--a-loop) |
+| `taskStreamMinCalls` | `3` | Same-tool calls required inside the window before a task stream is recognized |
+| `taskStreamTwinThreshold` | `0.99` | Arguments this similar (or identical) count as *the same task* — a twin invalidates the stream and re-enables normal loop detection |
 | `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
 
@@ -286,8 +340,8 @@ Modular extension with zero external dependencies (only pi's bundled `@earendil-
 - **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 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)
+- **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.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.",
+  "version": "1.3.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. Task-stream recognition: when an extension (punched, plan, …) makes the model call the SAME tool many times with DIFFERENT content — N distinct tasks of one type, e.g. appending lines or adding plan tasks — antiloop stays silent.",
   "keywords": [
     "pi-package",
     "antiloop",

package/src/commands.ts

@@ -59,9 +59,14 @@ async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<vo
 		`  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)`,
+		`  task streams: ${yn(rt.config.detectTaskStreams)} (min ${rt.config.taskStreamMinCalls} calls, twins ≥ ${(rt.config.taskStreamTwinThreshold * 100).toFixed(0)}%)`,
 		"",
 		`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 (rt.state.activeTaskStreams.length) {
+		lines.push("", `active batch: ${rt.state.activeTaskStreams.map((x) => `${x.tool}×${x.count}`).join(", ")}`);
+	}
 	if (recent.length) {
 		lines.push("", "recent:");
 		for (const d of recent) lines.push(`  [${d.type}] ${d.description} · ${formatDuration(Date.now() - d.timestamp)} ago`);
@@ -80,11 +85,16 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 		{ 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: "streams" as const, label: `task streams: ${yn(c.detectTaskStreams)}`, description: "batch work via extensions (punched_log / plan_manager / …) is not a loop" },
+		{ value: "streamMin" as const, label: `stream min calls: ${c.taskStreamMinCalls}`, description: "same tool calls required before batch recognition kicks in" },
+		{ value: "streamTwin" as const, label: `stream twin threshold: ${(c.taskStreamTwinThreshold * 100).toFixed(0)}%`, description: "args this similar = same task repeated → not a stream" },
 		{ 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;
@@ -166,6 +176,28 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 			if (v !== undefined) { c.resultSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`result similarity: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
+		case "streams":
+			c.detectTaskStreams = !c.detectTaskStreams; saveConfig(c);
+			ctx.ui.notify(`task streams: ${yn(c.detectTaskStreams)}`, "info"); break;
+		case "streamMin": {
+			const v = await selectFrom(ctx, "stream min calls", [
+				{ value: 2, label: "2 (sensitive)" },
+				{ value: 3, label: "3 (default)" },
+				{ value: 4, label: "4" },
+				{ value: 5, label: "5 (conservative)" },
+			]);
+			if (v !== undefined) { c.taskStreamMinCalls = v; saveConfig(c); ctx.ui.notify(`stream min calls: ${v}`, "info"); }
+			break;
+		}
+		case "streamTwin": {
+			const v = await selectFrom(ctx, "stream twin threshold (args)", [
+				{ value: 0.99, label: "99% (default — any real difference = distinct task)" },
+				{ value: 0.95, label: "95% (near-identical args count as same task)" },
+				{ value: 0.9, label: "90% (aggressive loop detection)" },
+			]);
+			if (v !== undefined) { c.taskStreamTwinThreshold = v; saveConfig(c); ctx.ui.notify(`stream twin threshold: ${(v * 100).toFixed(0)}%`, "info"); }
+			break;
+		}
 		case "window": {
 			const v = await selectFrom(ctx, "window", [
 				{ value: 5, label: "5" },
@@ -188,6 +220,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;
@@ -213,6 +259,7 @@ async function showLog(ctx: ExtensionCommandContext, rt: Runtime): Promise<void>
 export function resetState(state: AntiloopState): void {
 	state.recentMessages = [];
 	state.detections = [];
+	state.activeTaskStreams = [];
 	state.currentLevel = 0;
 	state.consecutiveDetections = 0;
 	state.inForcedBreak = false;

package/src/config.ts

@@ -16,12 +16,17 @@ export const DEFAULT_CONFIG: AntiloopConfig = {
 	toolSimilarityThreshold: 0.95,
 	minToolRepeatCount: 2,
 	resultSimilarityThreshold: 0.8,
+	detectTaskStreams: true,
+	taskStreamMinCalls: 3,
+	taskStreamTwinThreshold: 0.99,
 	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, TrackedToolCall } from "./types.ts";
+import type { AntiloopConfig, AntiloopState, LoopDetection, TrackedMessage, TrackedToolCall } from "./types.ts";
 
 const MIN_CONTENT_LENGTH = 50;
 
@@ -108,6 +108,71 @@ function toolCallsSimilar(
 	return true;
 }
 
+// ---------------------------------------------------------------------------
+// Task-stream recognition (batch work).
+//
+// Extensions like `punched` (append lines to pi.md) or `plan` (add tasks) make
+// the model call the SAME tool many times in a row with DIFFERENT content:
+// N distinct tasks of the same type — "adding line 1…N to a doc", "adding task
+// 1…N to the plan". That is not a reasoning loop, and antiloop must not fire.
+//
+// A tool is an active task stream when, inside the detection window, it was
+// called at least taskStreamMinCalls times and NO two calls are "twins"
+// (args ≥ taskStreamTwinThreshold similar). Twins = the same task repeated;
+// a stream with twins is indistinguishable from a loop and stays detected.
+// The check is name-agnostic: any extension tool used as a batch is covered.
+// ---------------------------------------------------------------------------
+
+/** Near-identity of two argument payloads — unlike similarity() it works on
+ * short args (JSON templates like {"action":"add",...} are < 50 chars, where
+ * similarity() bails to 0).
+ */
+function argsTwin(a: string, b: string, threshold: number): boolean {
+	const na = normalizeText(a);
+	const nb = normalizeText(b);
+	if (!na.length || !nb.length) return na === nb;
+	if (na === nb) return true;
+	if (na.length < 100 && nb.length < 100) {
+		const max = Math.max(na.length, nb.length);
+		return max > 0 && 1 - levenshtein(na, nb) / max >= threshold;
+	}
+	return similarity(a, b) >= threshold;
+}
+
+/**
+ * Map of tool name → call count for tools currently used as a homogeneous
+ * task stream in the given window. Empty map = no batch work recognized.
+ */
+export function detectTaskStreams(
+	win: TrackedMessage[],
+	config: AntiloopConfig,
+): Map<string, number> {
+	const streams = new Map<string, number>();
+	if (!config.detectTaskStreams || win.length < config.taskStreamMinCalls) return streams;
+
+	const callsByName = new Map<string, string[]>();
+	for (const m of win) {
+		for (const tc of m.toolCalls ?? []) {
+			const arr = callsByName.get(tc.name) ?? [];
+			arr.push(tc.args);
+			callsByName.set(tc.name, arr);
+		}
+	}
+
+	for (const [name, argsList] of callsByName) {
+		if (argsList.length < config.taskStreamMinCalls) continue;
+		let twins = 0;
+		for (let i = 0; i < argsList.length; i++) {
+			for (let j = i + 1; j < argsList.length; j++) {
+				if (argsTwin(argsList[i], argsList[j], config.taskStreamTwinThreshold)) twins++;
+			}
+		}
+		// Every call is a distinct task → batch work, exempt from loop detection.
+		if (twins === 0) streams.set(name, argsList.length);
+	}
+	return streams;
+}
+
 export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopDetection[] {
 	const out: LoopDetection[] = [];
 	const msgs = state.recentMessages;
@@ -116,13 +181,28 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 	const win = msgs.slice(start);
 	const now = Date.now();
 
+	// Task-stream gate: if the window is a homogeneous batch (same extension
+	// tool called with DISTINCT content ≥ taskStreamMinCalls times), that tool
+	// is exempt from tool-loop detection, and text/thinking/structural
+	// detections that only involve batch messages are suppressed too — the
+	// model is doing N different tasks of the same type, not looping.
+	const streams = detectTaskStreams(win, config);
+	const batchAt = new Set<number>();
+	win.forEach((m, idx) => {
+		const calls = m.toolCalls;
+		if (calls && calls.length && calls.every((c) => (streams.get(c.name) ?? 0) >= config.taskStreamMinCalls)) {
+			batchAt.add(start + idx);
+		}
+	});
+	const allBatch = (idxs: number[]): boolean => idxs.every((i) => batchAt.has(i));
+
 	if (config.detectTextLoops) {
 		const last = win[win.length - 1];
 		if (last.content.length >= MIN_CONTENT_LENGTH) {
 			for (let i = 0; i < win.length - 1; i++) {
 				if (win[i].content.length < MIN_CONTENT_LENGTH) continue;
 				const s = similarity(last.content, win[i].content);
-				if (s >= config.similarityThreshold) {
+				if (s >= config.similarityThreshold && !allBatch([start + i, msgs.length - 1])) {
 					out.push({
 						type: "text",
 						similarity: s,
@@ -142,7 +222,7 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 				for (let i = 0; i < opens.length - 1; i++) {
 					if (similarity(last, opens[i].o) > 0.9) n++;
 				}
-				if (n >= 2) {
+				if (n >= 2 && !allBatch([msgs.length - 1])) {
 					out.push({
 						type: "structural",
 						similarity: 0.9,
@@ -158,7 +238,9 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 	if (config.detectToolLoops) {
 		const last = win[win.length - 1];
 		const lastCalls = last.toolCalls;
-		if (lastCalls && lastCalls.length) {
+		// A message whose calls are all task-stream tools is batch work — skip
+		// it entirely (the stream gate already proved the calls are distinct).
+		if (lastCalls && lastCalls.length && !batchAt.has(msgs.length - 1)) {
 			const matched: number[] = [];
 			for (let i = 0; i < win.length - 1; i++) {
 				const prev = win[i].toolCalls;
@@ -187,7 +269,7 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 			for (let i = 0; i < win.length - 1; i++) {
 				if (win[i].thinking && win[i].thinking!.length > 50) {
 					const s = similarity(last.thinking, win[i].thinking!);
-					if (s >= config.similarityThreshold) {
+					if (s >= config.similarityThreshold && !allBatch([start + i, msgs.length - 1])) {
 						out.push({
 							type: "thinking",
 							similarity: s,
@@ -276,5 +358,67 @@ export function runSelfTest(): string[] {
 	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 ? "✅" : "❌"}`);
 
+	// --- task streams: extension batch work is NOT a loop ---
+	// punched_log / plan_manager / obsidian_* style tools: the model calls the
+	// SAME tool N times with DIFFERENT content ("add line 1…N", "add task 1…N").
+	// Near-identical template args (98.9% similar here) WOULD match the tool
+	// detector; the task-stream gate must suppress the whole window instead.
+	const mk = (content: string, toolCalls?: TrackedToolCall[]): TrackedMessage =>
+		({ content, toolCalls, timestamp: Date.now(), turnIndex: 0 });
+	const noteArgs = (x: string) =>
+		JSON.stringify({ type: "note", title: `task ${x}`, body: "append this line to the project memory document so context is preserved" });
+	const tcfg: 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, interactiveFooter: true, toggleShortcut: "esc+a",
+		detectTaskStreams: true, taskStreamMinCalls: 3, taskStreamTwinThreshold: 0.99,
+	};
+	const asState = (recentMessages: TrackedMessage[]): AntiloopState =>
+		({ recentMessages, detections: [], activeTaskStreams: [], currentLevel: 0,
+			consecutiveDetections: 0, inForcedBreak: false, totalDetections: 0,
+			lastUserMessageTime: 0, lastDetectedTurnIndex: -1 });
+	const NARR = "Now I will append the next decision entry to the project memory document so we keep the context.";
+
+	// 1) punched_log batch: 3 DIFFERENT appends (args 98.9% similar, NOT twins)
+	//    → stream recognized, tool + text + structural all suppressed.
+	const batchMsgs = [
+		mk(NARR, [{ name: "punched_log", args: noteArgs("1") }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("2") }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("3") }]),
+	];
+	const batchWin = batchMsgs.slice(-tcfg.detectionWindow);
+	const batchStreams = detectTaskStreams(batchWin, tcfg);
+	const batchDet = detectLoops(asState(batchMsgs), tcfg);
+	out.push(`batch stream detected  → ${batchStreams.get("punched_log") === 3 ? `punched_log×${batchStreams.get("punched_log")}` : "no"} (exp punched_log×3) ${batchStreams.get("punched_log") === 3 ? "✅" : "❌"}`);
+	out.push(`batch no detections    → ${batchDet.length === 0 ? "silent" : `${batchDet.map((d) => d.type).join(",")}`} (exp silent — 98.9% args would match without gate) ${batchDet.length === 0 ? "✅" : "❌"}`);
+
+	// 2) genuine loop: SAME call repeated verbatim → twins → stream inactive,
+	//    tool detection must still fire.
+	const loopMsgs = [
+		mk(NARR, [{ name: "punched_log", args: noteArgs("1") }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("1") }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("1") }]),
+	];
+	const loopDet = detectLoops(asState(loopMsgs), tcfg);
+	out.push(`loop still detected     → ${loopDet.some((d) => d.type === "tool") ? "tool" : "no"} (exp tool — identical repeats are NOT a stream) ${loopDet.some((d) => d.type === "tool") ? "✅" : "❌"}`);
+
+	// 3) coexistence: batch tool + a genuinely repeated bash command in the
+	//    same messages → the bash loop must still be flagged.
+	const loopCmd = "cd /tmp && sleep 1 && echo retrying the same build step again and again forever";
+	const mixedMsgs = [
+		mk(NARR, [{ name: "punched_log", args: noteArgs("1") }, { name: "bash", args: loopCmd }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("2") }, { name: "bash", args: loopCmd }]),
+		mk(NARR, [{ name: "punched_log", args: noteArgs("3") }, { name: "bash", args: loopCmd }]),
+	];
+	const mixedDet = detectLoops(asState(mixedMsgs), tcfg);
+	out.push(`loop survives batch gate→ ${mixedDet.some((d) => d.type === "tool") ? "tool" : "no"} (exp tool — bash repeats are real) ${mixedDet.some((d) => d.type === "tool") ? "✅" : "❌"}`);
+
+	// 4) below min calls: 2 distinct appends → no stream (could be coincidence).
+	const twoMsgs = [mk("a", [{ name: "punched_log", args: noteArgs("1") }]), mk("b", [{ name: "punched_log", args: noteArgs("2") }])];
+	const twoStreams = detectTaskStreams(twoMsgs, tcfg);
+	out.push(`stream needs ≥3 calls   → ${twoStreams.size === 0 ? "no stream" : "stream"} (exp no stream at 2 calls) ${twoStreams.size === 0 ? "✅" : "❌"}`);
+
 	return out;
 }

package/src/index.ts

@@ -1,19 +1,22 @@
 /**
  * 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 { 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 {
 		recentMessages: [],
 		detections: [],
+		activeTaskStreams: [],
 		currentLevel: 0,
 		consecutiveDetections: 0,
 		inForcedBreak: false,
@@ -23,22 +26,58 @@ function newState(): AntiloopState {
 	};
 }
 
+/** 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,
+	 * plus active batch streams so a quiet antiloop is explainable. */
+	function antiloopStatusText(): string {
+		if (!config.enabled) return "🔄 antiloop(off)";
+		const base =
+			state.currentLevel === 0
+				? "🔄 antiloop(on)"
+				: `${ICONS[state.currentLevel]} antiloop(on)×${state.consecutiveDetections}`;
+		if (state.activeTaskStreams.length) {
+			const s = state.activeTaskStreams.map((x) => `${x.tool}×${x.count}`).join(", ");
+			return `${base} · batch: ${s}`;
+		}
+		return base;
+	}
+
 	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);
@@ -59,12 +98,109 @@ 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;
 		}
 	}
 
+	// ------------------------------------------------------------------
+	// 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;
@@ -139,7 +275,7 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 
 	pi.on("turn_end", async (event, ctx) => {
 		if (!config.enabled) return;
-		const { detectLoops, interventionMessage, resultFingerprint } = await import("./detect.ts");
+		const { detectLoops, detectTaskStreams, 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)
@@ -165,6 +301,14 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 			}
 		}
 
+		// Recomputed batch streams (punched_log / plan_manager / … used as a
+		// homogeneous task stream) — shown in the footer so the user sees why
+		// antiloop stays quiet while the model performs N tasks of one type.
+		const winStart = Math.max(0, state.recentMessages.length - config.detectionWindow);
+		state.activeTaskStreams = Array.from(
+			detectTaskStreams(state.recentMessages.slice(winStart), config).entries(),
+		).map(([tool, count]) => ({ tool, count }));
+
 		const detections = detectLoops(state, config);
 		processDetections(detections, interventionMessage);
 
@@ -180,9 +324,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) => {
@@ -195,5 +347,3 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		},
 	});
 }
-
-

package/src/types.ts

@@ -25,12 +25,36 @@ export interface AntiloopConfig {
 	 * loop. Same command + different outcome = progress, not a loop.
 	 */
 	resultSimilarityThreshold: number;
+	/**
+	 * Task-stream recognition (batch work). Extensions like punched (append
+	 * lines to pi.md) or plan (add tasks) make the model call the SAME tool
+	 * many times with DIFFERENT content — N distinct tasks of the same type,
+	 * not a loop. When the same tool appears at least taskStreamMinCalls times
+	 * in the window and no two calls are "twins" (args ≥ taskStreamTwinThreshold
+	 * similar), antiloop treats that tool as an active task stream and does not
+	 * flag repetitions of it, nor text/thinking/structural patterns that only
+	 * involve those batch messages.
+	 */
+	detectTaskStreams: boolean;
+	taskStreamMinCalls: number;
+	taskStreamTwinThreshold: 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";
@@ -64,9 +88,18 @@ export interface TrackedMessage {
 	turnIndex: number;
 }
 
+export interface TaskStreamInfo {
+	tool: string;
+	count: number;
+}
+
 export interface AntiloopState {
 	recentMessages: TrackedMessage[];
 	detections: LoopDetection[];
+	/** Tools currently being used as a homogeneous batch (N tasks, same type).
+	 * Recomputed at turn_end; shown in the footer/status so a quiet antiloop is
+	 * explainable. */
+	activeTaskStreams: TaskStreamInfo[];
 	currentLevel: 0 | 1 | 2 | 3;
 	consecutiveDetections: number;
 	inForcedBreak: boolean;
@@ -81,4 +114,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;
 }