pi-antiloop 1.2.0 → 1.3.0

package/README.md

@@ -13,6 +13,7 @@
 ## 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
@@ -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.
 
@@ -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,6 +270,9 @@ 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,
@@ -247,6 +294,9 @@ 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 |

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-antiloop",
-  "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.",
+  "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,10 +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`);
@@ -81,6 +85,9 @@ 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)}` },
@@ -169,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" },
@@ -230,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,6 +16,9 @@ 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,

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

@@ -16,6 +16,7 @@ function newState(): AntiloopState {
 	return {
 		recentMessages: [],
 		detections: [],
+		activeTaskStreams: [],
 		currentLevel: 0,
 		consecutiveDetections: 0,
 		inForcedBreak: false,
@@ -42,11 +43,19 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 	/** 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. */
+	/** 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)";
-		if (state.currentLevel === 0) return "🔄 antiloop(on)";
-		return `${ICONS[state.currentLevel]} antiloop(on)×${state.consecutiveDetections}`;
+		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 {
@@ -266,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)
@@ -292,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);
 

package/src/types.ts

@@ -25,6 +25,19 @@ 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;
@@ -75,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;