pi-antiloop 1.4.0 → 1.5.0

package/README.md

@@ -61,7 +61,7 @@ pi remove npm:pi-antiloop
 /antiloop config     # adjust thresholds to taste
 ```
 
-That's it. Antiloop is on by default. If the model ever starts repeating itself, you'll see a `⚠️ antiloop(N)` warning; if it keeps looping past the force-break threshold, antiloop injects an "abort this pattern now" instruction into the context.
+That's it. Antiloop is on by default. If the model ever starts repeating itself, you'll see a `⚠️` warning; if it keeps looping past the force-break threshold, antiloop steers a break message into the *running* agent before its next tool call — and if the model ignores it and keeps repeating verbatim, antiloop aborts the run. Loops always terminate.
 
 ## Commands
 
@@ -106,35 +106,35 @@ Recent detections:
 
 ### `/antiloop config`
 
-Menú interactivo agrupado, con el valor actual en cada opción:
+Grouped interactive menu showing the current value in each option:
 
 **🎛️ General**
-- **🟢/🔴 activar/desactivar** — enciende o apaga la detección
-- **⏳ ventana** — `5 / 10 / 15 / 20` — cuántos mensajes recientes se analizan (por defecto 10)
-- **🔔 avisos** — on/off — avisa cuando detecta un bucle
-- **📊 pie interactivo** — on/off — experimental: reemplaza el pie de pantalla de pi y captura el teclado para el atajo (si da problemas de rendimiento, déjalo en off)
-- **⌨️ atajo** — `esc+a` o desactivado — pulsación para activar/apagar sin teclear nada
-
-**🎯 Detección**
-- **⚠️ umbral de aviso** — `1 / 2 / 3 / 5` — repeticiones antes de avisar (por defecto 2)
-- **🛑 umbral de corte** — `2 / 3 / 5 / 8` — repeticiones antes de forzar un cambio de rumbo (por defecto 3)
-- **🚨 umbral de aborto** — `desactivado / 5 / 8 / 10 / 15` — repeticiones antes de abortar (0 = desactivado)
-- **📏 parecido mínimo** — `50 / 60 / 70 / 75 / 80 / 90%` — qué tan parecidos deben ser dos mensajes para contar como bucle (por defecto 75%)
-- **🔧 parecido de llamadas** — `99 / 95 / 90 / 80%` — qué tan idénticas deben ser las llamadas para contar como la misma (por defecto 95%: solo repeticiones casi idénticas son bucle)
-- **🔁 repeticiones de llamada** — `1 / 2 / 3` — cuántas veces se repite la misma llamada antes de marcarla (por defecto 2)
-- **🧾 parecido de resultados** — `95 / 80 / 60%` — qué tan parecidos deben ser los resultados para contar como el *mismo resultado*; si un comando repetido empieza a dar otro resultado, es progreso y no bucle (por defecto 80%)
-
-**📋 Lotes de tareas** — el trabajo en lote (punched_log, plan_manager, …) es N tareas de un tipo, no un bucle
-- **📋 lotes de tareas** — on/off — reconoce ese trabajo en lote y se queda en silencio
-- **📋 llamadas mínimas** — `2 / 3 / 4 / 5` — llamadas de la misma herramienta antes de reconocer un lote (por defecto 3)
-- **📋 gemelos** — `99 / 95 / 90%` — llamadas más parecidas que esto cuentan como la *misma tarea* repetida; un gemelo invalida el lote y vuelve a la detección normal (por defecto 99%)
-
-**🔍 Detectores**
-- **📝 texto** — on/off — detecta mensajes de texto repetidos
-- **🔧 herramientas** — on/off — detecta llamadas a herramientas repetidas
-- **🧠 pensamiento** — on/off — detecta bloques de razonamiento repetidos
-
-**🧹 reiniciar estado** — borra contadores e historial
+- **🟢/🔴 enable/disable** — turn detection on or off
+- **⏳ window** — `5 / 10 / 15 / 20` — how many recent messages are analyzed (default 10)
+- **🔔 notifications** — on/off — show a warning when a loop is detected
+- **📊 interactive footer** — on/off — experimental: replaces pi's footer and captures keystrokes for the toggle shortcut (leave it off if it misbehaves)
+- **⌨️ shortcut** — `esc+a` or off — key press to toggle without typing a command
+
+**🎯 Detection**
+- **⚠️ warn threshold** — `1 / 2 / 3 / 5` — repetitions before antiloop warns you (default 2)
+- **🛑 force break threshold** — `2 / 3 / 5 / 8` — repetitions before forcing a change of approach (default 3)
+- **🚨 abort threshold** — `off / 5 / 8 / 10 / 15` — repetitions before aborting (0 = disabled)
+- **📏 text similarity** — `50 / 60 / 70 / 75 / 80 / 90%` — how similar two messages must be to count as a loop (default 75%)
+- **🔧 call similarity** — `99 / 95 / 90 / 80%` — how identical tool-call *arguments* must be to count as the same call (default 95%: only near-identical repeats loop)
+- **🔁 call repeats** — `1 / 2 / 3` — how many times the same call must repeat before it flags (default 2)
+- **🧾 result similarity** — `95 / 80 / 60%` — how similar captured results must be to count as the *same outcome*; a repeated command that starts producing a different result is progress, not a loop (default 80%)
+
+**📋 Task streams** — batch work (punched_log, plan_manager, …) is N tasks of one type, not a loop
+- **📋 task streams** — on/off — recognize that batch work and stay silent
+- **📋 stream min calls** — `2 / 3 / 4 / 5` — same-tool calls required before a batch is recognized (default 3)
+- **📋 twin threshold** — `99 / 95 / 90%` — calls more similar than this count as the *same task* repeated; one twin invalidates the batch and normal detection resumes (default 99%)
+
+**🔍 Detectors**
+- **📝 text** — on/off — detect repeated text messages
+- **🔧 tools** — on/off — detect repeated tool calls
+- **🧠 thinking** — on/off — detect repeated internal reasoning
+
+**🧹 reset state** — clear all counters and history
 
 ### `/antiloop log`
 
@@ -353,7 +353,8 @@ Modular extension with zero external dependencies (only pi's bundled `@earendil-
 - **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` + 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)
+- **Hooks** — `message_end` (track messages + tool call ids), `turn_end` (attach result fingerprints, detect, and intervene: steer the force break / abort the run), `input` (decay on real user messages only), `session_start` (load config + install footer + reset), `session_shutdown` (restore built-in footer)
+- **Intervention runs on the turn loop, not on user prompts** — escalation is decided at `turn_end`, the break is steered into the running agent before its next LLM call, and the guaranteed hard stop aborts the run (`ctx.abort`, fire-and-forget — never awaited, so the hook can't deadlock). No custom-role messages are injected into the conversation at any level (steering a real user message + aborting are the only levers; custom-role injections were removed because a model can stall on an unexpected injected message)
 
 ## License
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pi-antiloop",
-  "version": "1.4.0",
-  "description": "Antiloop: detect reasoning loops and force a break (warn \u2192 force \u2192 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, \u2026) makes the model call the SAME tool many times with DIFFERENT content \u2014 N distinct tasks of one type, e.g. appending lines or adding plan tasks \u2014 antiloop stays silent.",
+  "version": "1.5.0",
+  "description": "Antiloop: detect reasoning loops and force a break (warn \u2192 force \u2192 abort) across text, tool, thinking, and structural patterns. The force break is delivered mid-run: a real break message is steered into the running agent right before its next LLM call, and if the model ignores it and keeps repeating verbatim, antiloop aborts the run \u2014 an autonomous tool loop always terminates. 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, \u2026) makes the model call the SAME tool many times with DIFFERENT content \u2014 N distinct tasks of one type, e.g. appending lines or adding plan tasks \u2014 antiloop stays silent.",
   "keywords": [
     "pi-package",
     "antiloop",

package/src/commands.ts

@@ -32,7 +32,6 @@ export async function handleCommand(
 			return showLog(ctx, rt);
 		case "reset":
 			resetState(rt.state);
-			rt.pendingIntervention = null;
 			ctx.ui.notify("antiloop: reset", "info");
 			rt.updateStatus(ctx);
 			return;
@@ -52,10 +51,10 @@ async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<vo
 	const recent = rt.state.detections.slice(-5);
 	const lines = [
 		`state: ${rt.config.enabled ? "ON" : "OFF"} · level: ${lvl} · consecutive: ${rt.state.consecutiveDetections}`,
-		`total: ${rt.state.totalDetections} · tracked: ${rt.state.recentMessages.length} · forced: ${rt.state.inForcedBreak ? "yes" : "no"}`,
+		`total: ${rt.state.totalDetections} · tracked: ${rt.state.recentMessages.length} · forced: ${rt.state.inForcedBreak ? "yes" : "no"} · steer: ${rt.state.steerDelivered ? `sent (${rt.state.ignoredSteerCount} ignored)` : "armed"}`,
 		"",
 		"thresholds:",
-		`  warn: ${rt.config.warningThreshold}  force: ${rt.config.forceBreakThreshold}  abort: ${rt.config.abortThreshold || "off"}`,
+		`  warn: ${rt.config.warningThreshold}  force: ${rt.config.forceBreakThreshold}  abort: ${rt.config.abortThreshold || "off"}  stop-after-ignored-break: ${rt.config.ignoredSteerLimit}`,
 		`  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)`,
@@ -78,29 +77,30 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 	const c = rt.config;
 	const picked = await selectFrom(ctx, "⚙️ antiloop config", [
 		// ── 🎛️ General ──────────────────────────────────────────────
-		{ value: "toggle" as const, label: c.enabled ? "🟢 desactivar" : "🔴 activar", description: "enciende o apaga la detección" },
-		{ value: "window" as const, label: `⏳ ventana: ${c.detectionWindow} msgs`, description: "cuántos mensajes recientes se analizan" },
-		{ value: "notify" as const, label: `🔔 avisos: ${yn(c.notifyOnDetection)}`, description: "avisa cuando detecta un bucle" },
-		{ value: "footer" as const, label: `📊 pie interactivo: ${yn(c.interactiveFooter)}`, description: "experimental: reemplaza el pie de pi y captura el teclado (si da problemas, déjalo en off)" },
-		{ value: "shortcut" as const, label: `⌨️ atajo: ${c.toggleShortcut}`, description: "esc+a o desactivado" },
-		// ── 🎯 Detección ────────────────────────────────────────────
-		{ value: "warn" as const, label: `⚠️ umbral aviso: ${c.warningThreshold}`, description: "repeticiones antes de avisar" },
-		{ value: "force" as const, label: `🛑 umbral corte: ${c.forceBreakThreshold}`, description: "repeticiones antes de forzar un cambio de rumbo" },
-		{ value: "abort" as const, label: `🚨 umbral abortar: ${c.abortThreshold || "off"}`, description: "repeticiones antes de abortar (0 = desactivado)" },
-		{ value: "sim" as const, label: `📏 parecido mínimo: ${(c.similarityThreshold * 100).toFixed(0)}%`, description: "qué tan parecidos deben ser dos mensajes para contar como bucle" },
-		{ value: "toolSim" as const, label: `🔧 parecido de llamadas: ${(c.toolSimilarityThreshold * 100).toFixed(0)}%`, description: "qué tan idénticas deben ser las llamadas para contar como la misma" },
-		{ value: "toolRepeat" as const, label: `🔁 repeticiones de llamada: ${c.minToolRepeatCount}+`, description: "cuántas veces se repite la misma llamada antes de marcarla" },
-		{ value: "resultSim" as const, label: `🧾 parecido de resultados: ${(c.resultSimilarityThreshold * 100).toFixed(0)}%`, description: "mismo comando + resultado distinto = progreso, no bucle" },
+		{ value: "toggle" as const, label: c.enabled ? "🟢 disable" : "🔴 enable", description: "turn detection on or off" },
+		{ value: "window" as const, label: `⏳ window: ${c.detectionWindow} msgs`, description: "how many recent messages are analyzed" },
+		{ value: "notify" as const, label: `🔔 notifications: ${yn(c.notifyOnDetection)}`, description: "show a warning when a loop is detected" },
+		{ value: "footer" as const, label: `📊 interactive footer: ${yn(c.interactiveFooter)}`, description: "experimental: replaces pi's footer and captures keystrokes (leave off if it misbehaves)" },
+		{ value: "shortcut" as const, label: `⌨️ shortcut: ${c.toggleShortcut}`, description: "keys to toggle on/off without typing a command" },
+		// ── 🎯 Detection ────────────────────────────────────────────
+		{ value: "warn" as const, label: `⚠️ warn after: ${c.warningThreshold}`, description: "repetitions before antiloop warns you" },
+		{ value: "force" as const, label: `🛑 force break after: ${c.forceBreakThreshold}`, description: "repetitions before forcing a change of approach" },
+		{ value: "abort" as const, label: `🚨 abort after: ${c.abortThreshold || "off"}`, description: "repetitions before aborting (0 = disabled)" },
+		{ value: "ignoredBreak" as const, label: `🛑 stop after ignored break: ${c.ignoredSteerLimit}`, description: "identical repeats allowed after the force break before antiloop stops the run" },
+		{ value: "sim" as const, label: `📏 text similarity: ${(c.similarityThreshold * 100).toFixed(0)}%`, description: "how similar two messages must be to count as a loop" },
+		{ value: "toolSim" as const, label: `🔧 call similarity: ${(c.toolSimilarityThreshold * 100).toFixed(0)}%`, description: "how identical tool calls must be to count as the same call" },
+		{ value: "toolRepeat" as const, label: `🔁 call repeats: ${c.minToolRepeatCount}+`, description: "how many times the same call must repeat before it flags" },
+		{ value: "resultSim" as const, label: `🧾 result similarity: ${(c.resultSimilarityThreshold * 100).toFixed(0)}%`, description: "same command + different result = progress, not a loop" },
 		// ── 📋 Task streams ─────────────────────────────────────────
-		{ value: "streams" as const, label: `📋 lotes de tareas: ${yn(c.detectTaskStreams)}`, description: "trabajo en lote (punched_log / plan_manager / …) no es un bucle" },
-		{ value: "streamMin" as const, label: `📋 llamadas mínimas: ${c.taskStreamMinCalls}`, description: "llamadas de la misma herramienta antes de reconocer un lote" },
-		{ value: "streamTwin" as const, label: `📋 gemelos: ${(c.taskStreamTwinThreshold * 100).toFixed(0)}%`, description: "llamadas más parecidas que esto = la misma tarea repetida, no un lote" },
-		// ── 🔍 Detectores ───────────────────────────────────────────
-		{ value: "text" as const, label: `📝 texto: ${yn(c.detectTextLoops)}`, description: "detecta mensajes de texto repetidos" },
-		{ value: "tool" as const, label: `🔧 herramientas: ${yn(c.detectToolLoops)}`, description: "detecta llamadas repetidas a herramientas" },
-		{ value: "think" as const, label: `🧠 pensamiento: ${yn(c.detectThinkingLoops)}`, description: "detecta razonamiento interno repetido" },
+		{ value: "streams" as const, label: `📋 task streams: ${yn(c.detectTaskStreams)}`, description: "batch work (punched_log / plan_manager / …) is not a loop" },
+		{ value: "streamMin" as const, label: `📋 stream min calls: ${c.taskStreamMinCalls}`, description: "calls of the same tool before a batch is recognized" },
+		{ value: "streamTwin" as const, label: `📋 twin threshold: ${(c.taskStreamTwinThreshold * 100).toFixed(0)}%`, description: "calls more similar than this = the same task repeated, not a batch" },
+		// ── 🔍 Detectors ────────────────────────────────────────────
+		{ value: "text" as const, label: `📝 text: ${yn(c.detectTextLoops)}`, description: "detect repeated text messages" },
+		{ value: "tool" as const, label: `🔧 tools: ${yn(c.detectToolLoops)}`, description: "detect repeated tool calls" },
+		{ value: "think" as const, label: `🧠 thinking: ${yn(c.detectThinkingLoops)}`, description: "detect repeated internal reasoning" },
 		// ── 🧹 ──────────────────────────────────────────────────────
-		{ value: "reset" as const, label: "🧹 reiniciar estado", description: "borra contadores e historial" },
+		{ value: "reset" as const, label: "🧹 reset state", description: "clear counters and history" },
 	]);
 	if (!picked) return;
 	switch (picked) {
@@ -111,138 +111,146 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 			rt.updateStatus(ctx);
 			break;
 		case "window": {
-			const v = await selectFrom(ctx, "⏳ ventana (mensajes a analizar)", [
+			const v = await selectFrom(ctx, "⏳ window (messages to analyze)", [
 				{ value: 5, label: "5" },
-				{ value: 10, label: "10 (por defecto)" },
+				{ value: 10, label: "🎯 10 (default)" },
 				{ value: 15, label: "15" },
 				{ value: 20, label: "20" },
 			]);
-			if (v !== undefined) { c.detectionWindow = v; saveConfig(c); ctx.ui.notify(`ventana: ${v}`, "info"); }
+			if (v !== undefined) { c.detectionWindow = v; saveConfig(c); ctx.ui.notify(`window: ${v}`, "info"); }
 			break;
 		}
 		case "notify":
 			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
-			ctx.ui.notify(`avisos: ${yn(c.notifyOnDetection)}`, "info"); break;
+			ctx.ui.notify(`notifications: ${yn(c.notifyOnDetection)}`, "info"); break;
 		case "footer":
 			c.interactiveFooter = !c.interactiveFooter; saveConfig(c);
-			ctx.ui.notify(`pie interactivo: ${yn(c.interactiveFooter)}`, "info");
+			ctx.ui.notify(`interactive footer: ${yn(c.interactiveFooter)}`, "info");
 			rt.refreshFooter?.(ctx);
 			rt.updateStatus(ctx);
 			break;
 		case "shortcut": {
-			const v = await selectFrom(ctx, "⌨️ atajo para activar/apagar", [
-				{ value: "esc+a" as const, label: "⌨️ esc+a (por defecto)", description: "pulsa ESC y luego a" },
-				{ value: "off" as const, label: "🚫 desactivado" },
+			const v = await selectFrom(ctx, "⌨️ toggle shortcut", [
+				{ value: "esc+a" as const, label: "⌨️ esc+a (default)", description: "press ESC then a" },
+				{ value: "off" as const, label: "🚫 off" },
 			]);
-			if (v !== undefined) { c.toggleShortcut = v; saveConfig(c); rt.refreshFooter?.(ctx); ctx.ui.notify(`atajo: ${v}`, "info"); }
+			if (v !== undefined) { c.toggleShortcut = v; saveConfig(c); rt.refreshFooter?.(ctx); ctx.ui.notify(`shortcut: ${v}`, "info"); }
 			break;
 		}
 		case "warn": {
-			const v = await selectFrom(ctx, "⚠️ umbral de aviso", [
-				{ value: 1, label: "⚡ 1 (sensible)" },
-				{ value: 2, label: "🎯 2 (por defecto)" },
+			const v = await selectFrom(ctx, "⚠️ warn threshold", [
+				{ value: 1, label: "⚡ 1 (sensitive)" },
+				{ value: 2, label: "🎯 2 (default)" },
 				{ value: 3, label: "3" },
-				{ value: 5, label: "🐢 5 (relajado)" },
+				{ value: 5, label: "🐢 5 (relaxed)" },
 			]);
-			if (v !== undefined) { c.warningThreshold = v; saveConfig(c); ctx.ui.notify(`aviso: ${v}`, "info"); }
+			if (v !== undefined) { c.warningThreshold = v; saveConfig(c); ctx.ui.notify(`warn: ${v}`, "info"); }
 			break;
 		}
 		case "force": {
-			const v = await selectFrom(ctx, "🛑 umbral de corte", [
-				{ value: 2, label: "⚡ 2 (sensible)" },
-				{ value: 3, label: "🎯 3 (por defecto)" },
+			const v = await selectFrom(ctx, "🛑 force break threshold", [
+				{ value: 2, label: "⚡ 2 (sensitive)" },
+				{ value: 3, label: "🎯 3 (default)" },
 				{ value: 5, label: "5" },
-				{ value: 8, label: "🐢 8 (relajado)" },
+				{ value: 8, label: "🐢 8 (relaxed)" },
 			]);
-			if (v !== undefined) { c.forceBreakThreshold = v; saveConfig(c); ctx.ui.notify(`corte: ${v}`, "info"); }
+			if (v !== undefined) { c.forceBreakThreshold = v; saveConfig(c); ctx.ui.notify(`force break: ${v}`, "info"); }
 			break;
 		}
 		case "abort": {
-			const v = await selectFrom(ctx, "🚨 umbral de aborto (0 = desactivado)", [
-				{ value: 0, label: "🚫 desactivado" },
+			const v = await selectFrom(ctx, "🚨 abort threshold (0 = disabled)", [
+				{ value: 0, label: "🚫 off" },
 				{ value: 5, label: "5" },
 				{ value: 8, label: "8" },
 				{ value: 10, label: "10" },
 				{ value: 15, label: "15" },
 			]);
-			if (v !== undefined) { c.abortThreshold = v; saveConfig(c); ctx.ui.notify(`aborto: ${v || "desactivado"}`, "info"); }
+			if (v !== undefined) { c.abortThreshold = v; saveConfig(c); ctx.ui.notify(`abort: ${v || "off"}`, "info"); }
 			break;
 		}
 		case "sim": {
-			const v = await selectFrom(ctx, "📏 parecido mínimo entre mensajes", [
-				{ value: 0.5, label: "⚡ 50% (sensible)" },
+			const v = await selectFrom(ctx, "📏 text similarity", [
+				{ value: 0.5, label: "⚡ 50% (sensitive)" },
 				{ value: 0.6, label: "60%" },
 				{ value: 0.7, label: "70%" },
-				{ value: 0.75, label: "🎯 75% (por defecto)" },
+				{ value: 0.75, label: "🎯 75% (default)" },
 				{ value: 0.8, label: "80%" },
-				{ value: 0.9, label: "🐢 90% (relajado)" },
+				{ value: 0.9, label: "🐢 90% (relaxed)" },
 			]);
-			if (v !== undefined) { c.similarityThreshold = v; saveConfig(c); ctx.ui.notify(`parecido: ${(v * 100).toFixed(0)}%`, "info"); }
+			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, "🔧 parecido de las llamadas (argumentos)", [
-				{ value: 0.99, label: "⚡ 99% (estricto)" },
-				{ value: 0.95, label: "🎯 95% (por defecto)" },
+			const v = await selectFrom(ctx, "🔧 call similarity (arguments)", [
+				{ value: 0.99, label: "⚡ 99% (strict)" },
+				{ value: 0.95, label: "🎯 95% (default)" },
 				{ value: 0.9, label: "90%" },
-				{ value: 0.8, label: "🐢 80% (sensible)" },
+				{ value: 0.8, label: "🐢 80% (sensitive)" },
 			]);
-			if (v !== undefined) { c.toolSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`parecido de llamadas: ${(v * 100).toFixed(0)}%`, "info"); }
+			if (v !== undefined) { c.toolSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`call similarity: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
 		case "toolRepeat": {
-			const v = await selectFrom(ctx, "🔁 repeticiones de la misma llamada", [
-				{ value: 1, label: "⚡ 1 (sensible)" },
-				{ value: 2, label: "🎯 2 (por defecto)" },
-				{ value: 3, label: "🐢 3 (relajado)" },
+			const v = await selectFrom(ctx, "🔁 call repeats", [
+				{ 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(`repeticiones: ${v}+`, "info"); }
+			if (v !== undefined) { c.minToolRepeatCount = v; saveConfig(c); ctx.ui.notify(`call repeats: ${v}+`, "info"); }
 			break;
 		}
 		case "resultSim": {
-			const v = await selectFrom(ctx, "🧾 parecido de resultados (veto de progreso)", [
-				{ value: 0.95, label: "⚡ 95% (estricto — solo resultados casi idénticos cuentan como igual)" },
-				{ value: 0.8, label: "🎯 80% (por defecto)" },
-				{ value: 0.6, label: "🐢 60% (relajado — tolera más ruido de salida)" },
+			const v = await selectFrom(ctx, "🧾 result similarity (progress veto)", [
+				{ value: 0.95, label: "⚡ 95% (strict — only near-identical results count as the same)" },
+				{ 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(`parecido de resultados: ${(v * 100).toFixed(0)}%`, "info"); }
+			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(`lotes de tareas: ${yn(c.detectTaskStreams)}`, "info"); break;
+			ctx.ui.notify(`task streams: ${yn(c.detectTaskStreams)}`, "info"); break;
 		case "streamMin": {
-			const v = await selectFrom(ctx, "📋 llamadas mínimas para reconocer un lote", [
-				{ value: 2, label: "⚡ 2 (sensible)" },
-				{ value: 3, label: "🎯 3 (por defecto)" },
+			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 (conservador)" },
+				{ value: 5, label: "🐢 5 (conservative)" },
 			]);
-			if (v !== undefined) { c.taskStreamMinCalls = v; saveConfig(c); ctx.ui.notify(`llamadas mínimas: ${v}`, "info"); }
+			if (v !== undefined) { c.taskStreamMinCalls = v; saveConfig(c); ctx.ui.notify(`stream min calls: ${v}`, "info"); }
 			break;
 		}
 		case "streamTwin": {
-			const v = await selectFrom(ctx, "📋 umbral de gemelos (argumentos)", [
-				{ value: 0.99, label: "🎯 99% (por defecto — cualquier diferencia real = tarea distinta)" },
-				{ value: 0.95, label: "95% (argumentos casi idénticos cuentan como la misma tarea)" },
-				{ value: 0.9, label: "⚡ 90% (detección de bucles más agresiva)" },
+			const v = await selectFrom(ctx, "📋 twin threshold (arguments)", [
+				{ value: 0.99, label: "🎯 99% (default — any real difference = distinct task)" },
+				{ value: 0.95, label: "95% (near-identical arguments count as the same task)" },
+				{ value: 0.9, label: "⚡ 90% (more aggressive loop detection)" },
 			]);
-			if (v !== undefined) { c.taskStreamTwinThreshold = v; saveConfig(c); ctx.ui.notify(`gemelos: ${(v * 100).toFixed(0)}%`, "info"); }
+			if (v !== undefined) { c.taskStreamTwinThreshold = v; saveConfig(c); ctx.ui.notify(`twin threshold: ${(v * 100).toFixed(0)}%`, "info"); }
+			break;
+		}
+		case "ignoredBreak": {
+			const v = await selectFrom(ctx, "🛑 stop after ignored break (identical repeats after the force break)", [
+				{ value: 1, label: "⚡ 1 (sensitive — one identical repeat after the break stops the run)" },
+				{ value: 2, label: "🎯 2 (default)" },
+				{ value: 3, label: "🐢 3 (lenient)" },
+			]);
+			if (v !== undefined) { c.ignoredSteerLimit = v; saveConfig(c); ctx.ui.notify(`stop after ignored break: ${v}`, "info"); }
 			break;
 		}
 		case "text":
 			c.detectTextLoops = !c.detectTextLoops; saveConfig(c);
-			ctx.ui.notify(`texto: ${yn(c.detectTextLoops)}`, "info"); break;
+			ctx.ui.notify(`text: ${yn(c.detectTextLoops)}`, "info"); break;
 		case "tool":
 			c.detectToolLoops = !c.detectToolLoops; saveConfig(c);
-			ctx.ui.notify(`herramientas: ${yn(c.detectToolLoops)}`, "info"); break;
+			ctx.ui.notify(`tools: ${yn(c.detectToolLoops)}`, "info"); break;
 		case "think":
 			c.detectThinkingLoops = !c.detectThinkingLoops; saveConfig(c);
-			ctx.ui.notify(`pensamiento: ${yn(c.detectThinkingLoops)}`, "info"); break;
+			ctx.ui.notify(`thinking: ${yn(c.detectThinkingLoops)}`, "info"); break;
 		case "reset":
 			resetState(rt.state);
-			rt.pendingIntervention = null;
-			ctx.ui.notify("🧹 estado reiniciado", "info");
+			ctx.ui.notify("🧹 state reset", "info");
 			rt.updateStatus(ctx);
 			break;
 	}
@@ -250,7 +258,7 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 
 async function showLog(ctx: ExtensionCommandContext, rt: Runtime): Promise<void> {
 	if (!rt.state.detections.length) {
-		ctx.ui.notify("no hay detecciones en esta sesión", "info");
+		ctx.ui.notify("no detections this session", "info");
 		return;
 	}
 	const items = rt.state.detections.slice(-30).reverse().map((d) => ({
@@ -258,7 +266,7 @@ async function showLog(ctx: ExtensionCommandContext, rt: Runtime): Promise<void>
 		label: `[${d.type}] ${d.description}`,
 		description: `${(d.similarity * 100).toFixed(0)}% · ${formatDuration(Date.now() - d.timestamp)} ago`,
 	}));
-	await selectFrom(ctx, `🕵️ detecciones (${rt.state.detections.length} en total)`, items);
+	await selectFrom(ctx, `🕵️ detections (${rt.state.detections.length} total)`, items);
 }
 
 export function resetState(state: AntiloopState): void {
@@ -270,6 +278,8 @@ export function resetState(state: AntiloopState): void {
 	state.inForcedBreak = false;
 	state.totalDetections = 0;
 	state.lastDetectedTurnIndex = -1;
+	state.steerDelivered = false;
+	state.ignoredSteerCount = 0;
 }
 
 async function runSelfTest(ctx: ExtensionCommandContext): Promise<void> {

package/src/config.ts

@@ -12,6 +12,7 @@ export const DEFAULT_CONFIG: AntiloopConfig = {
 	warningThreshold: 2,
 	forceBreakThreshold: 3,
 	abortThreshold: 0,
+	ignoredSteerLimit: 2,
 	similarityThreshold: 0.75,
 	toolSimilarityThreshold: 0.95,
 	minToolRepeatCount: 2,

package/src/detect.ts

@@ -287,15 +287,23 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 	return out;
 }
 
-export function interventionMessage(level: 1 | 2 | 3, detections: LoopDetection[]): string {
-	const det = detections.map((d) => `- ${d.description}`).join("\n");
-	if (level === 1) {
-		return `[antiloop] ⚠️ loop warning\n${det}\nvary approach — try a different strategy.`;
-	}
-	if (level === 2) {
-		return `[antiloop] 🛑 stuck in loop\n${det}\nstop, change approach, do NOT repeat previous tool calls or reasoning.`;
-	}
-	return `[antiloop] 🚨 persistent loop\n${det}\nunable to break automatically — provide new instructions.`;
+/** Escalation level for a consecutive-detection count (mirror of the configured
+ * ladder). Abort (3) only when abortThreshold is enabled (> 0). */
+export function nextLevel(consecutiveDetections: number, config: AntiloopConfig): 0 | 1 | 2 | 3 {
+	if (config.abortThreshold > 0 && consecutiveDetections >= config.abortThreshold) return 3;
+	if (consecutiveDetections >= config.forceBreakThreshold) return 2;
+	if (consecutiveDetections >= config.warningThreshold) return 1;
+	return 0;
+}
+
+/** True when detections prove the model repeated a message/tool call essentially
+ * verbatim (≥98% text similarity or an identical tool-loop). Weaker signals
+ * (thinking echoes, structural repeated openings at 90%) do NOT count — a model
+ * that only *thinks* in circles but varies its actual output is still making an
+ * attempt and must not be hard-stopped. Used post-force-break: only verbatim
+ * repeats prove the model ignored the break instruction. */
+export function isVerbatimRepeat(detections: LoopDetection[]): boolean {
+	return detections.some((d) => d.type !== "thinking" && d.similarity >= 0.98);
 }
 
 // ---------------------------------------------------------------------------
@@ -369,7 +377,7 @@ export function runSelfTest(): string[] {
 	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,
+		enabled: true, warningThreshold: 2, forceBreakThreshold: 3, abortThreshold: 0, ignoredSteerLimit: 2,
 		similarityThreshold: 0.75, toolSimilarityThreshold: 0.95, minToolRepeatCount: 2,
 		resultSimilarityThreshold: 0.8, detectToolLoops: true, detectThinkingLoops: true,
 		detectTextLoops: true, notifyOnDetection: true, maxHistoryEntries: 100,
@@ -379,7 +387,8 @@ export function runSelfTest(): string[] {
 	const asState = (recentMessages: TrackedMessage[]): AntiloopState =>
 		({ recentMessages, detections: [], activeTaskStreams: [], currentLevel: 0,
 			consecutiveDetections: 0, inForcedBreak: false, totalDetections: 0,
-			lastUserMessageTime: 0, lastDetectedTurnIndex: -1 });
+			lastUserMessageTime: 0, lastDetectedTurnIndex: -1,
+			steerDelivered: false, ignoredSteerCount: 0 });
 	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)
@@ -421,5 +430,18 @@ export function runSelfTest(): string[] {
 	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 ? "✅" : "❌"}`);
 
+	// --- v1.5: escalation ladder + post-steer verbatim-repeat gating ---
+	const lvl = (n: number) => nextLevel(n, tcfg);
+	out.push(`ladder 0→0 1→0 2→1 3→2 4→2  → ${[0, 1, 2, 3, 4].map(lvl).join(",")} (exp 0,0,1,2,2) ${[0, 1, 2, 3, 4].map(lvl).join(",") === "0,0,1,2,2" ? "✅" : "❌"}`);
+	const abortCfg: AntiloopConfig = { ...tcfg, abortThreshold: 5 };
+	out.push(`ladder abort@5 → 5→3       → ${nextLevel(5, abortCfg)} (exp 3) ${nextLevel(5, abortCfg) === 3 ? "✅" : "❌"}`);
+	const dl = (type: LoopDetection["type"], sim: number): LoopDetection[] =>
+		[{ type, similarity: sim, messageIndices: [0, 1], description: `${type} ${sim}`, timestamp: Date.now() }];
+	out.push(`verbatim text 1.00        → ${isVerbatimRepeat(dl("text", 1)) ? "yes" : "no"} (exp yes) ${isVerbatimRepeat(dl("text", 1)) ? "✅" : "❌"}`);
+	out.push(`verbatim text 0.97        → ${isVerbatimRepeat(dl("text", 0.97)) ? "yes" : "no"} (exp no — changed output = attempt) ${!isVerbatimRepeat(dl("text", 0.97)) ? "✅" : "❌"}`);
+	out.push(`verbatim tool-loop        → ${isVerbatimRepeat(dl("tool", 1)) ? "yes" : "no"} (exp yes) ${isVerbatimRepeat(dl("tool", 1)) ? "✅" : "❌"}`);
+	out.push(`thinking-only 1.00        → ${isVerbatimRepeat(dl("thinking", 1)) ? "yes" : "no"} (exp no — output varies) ${!isVerbatimRepeat(dl("thinking", 1)) ? "✅" : "❌"}`);
+	out.push(`structural 0.90           → ${isVerbatimRepeat(dl("structural", 0.9)) ? "yes" : "no"} (exp no) ${!isVerbatimRepeat(dl("structural", 0.9)) ? "✅" : "❌"}`);
+
 	return out;
 }

package/src/index.ts

@@ -1,7 +1,20 @@
 /**
  * antiloop — detect reasoning loops and intervene.
- * Hooks: message_end, input, before_agent_start, context, turn_end, session_start, session_shutdown.
+ * Hooks: message_end, input, turn_end, session_start, session_shutdown.
  * Commands: /antiloop [enable|disable|status|config|log|reset|test]
+ *
+ * Intervention model (v1.5):
+ *   warning (level 1) — informational only (notify). Never injects: an injected
+ *     message at warning level made models stall on the unexpected message.
+ *   force   (level 2) — a REAL user message is steered into the running agent
+ *     (pi.sendUserMessage, deliverAs "steer"); pi delivers it right after the
+ *     current tool results, immediately before the next LLM call, so it lands at
+ *     the exact spot where the model anchors — even a deterministic model stuck
+ *     on an identical context tail must respond to it. One steer per episode.
+ *     If the model ignores the steer and repeats the same message verbatim
+ *     (≥98% similar / identical tool loop) ignoredSteerLimit times, antiloop
+ *     hard-stops the run (ctx.abort).
+ *   abort   (level 3, opt-in via abortThreshold) — stops the run outright.
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -23,6 +36,8 @@ function newState(): AntiloopState {
 		totalDetections: 0,
 		lastUserMessageTime: 0,
 		lastDetectedTurnIndex: -1,
+		steerDelivered: false,
+		ignoredSteerCount: 0,
 	};
 }
 
@@ -54,8 +69,7 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		activeTui?.requestRender();
 	}
 
-	const rt: Runtime = { config, state, pendingIntervention: null, updateStatus, refreshFooter: installFooter };
-	const setPending = (v: string | null) => { rt.pendingIntervention = v; };
+	const rt: Runtime = { config, state, updateStatus, refreshFooter: installFooter };
 
 	/** Toggle enable/disable, persisting config and refreshing the footer. */
 	function toggleEnabled(ctx: ExtensionContext): void {
@@ -65,38 +79,65 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		updateStatus(ctx);
 	}
 
-	function processDetections(
-		detections: LoopDetection[],
-		interventionMessage: (level: 2 | 3, d: LoopDetection[]) => string,
-	): void {
-		if (!detections.length) {
-			if (state.consecutiveDetections > 0) state.consecutiveDetections = Math.max(0, state.consecutiveDetections - 1);
-			if (state.currentLevel > 0 && state.consecutiveDetections === 0) {
-				state.currentLevel = 0;
-				state.inForcedBreak = false;
+	/** Set the escalation level; keeps the derived inForcedBreak flag in sync. */
+	function applyLevel(level: 0 | 1 | 2 | 3): void {
+		state.currentLevel = level;
+		state.inForcedBreak = level >= 2;
+	}
+
+	/** level from the current consecutive count (lazy import wrapper). */
+	async function levelForConsecutive(): Promise<0 | 1 | 2 | 3> {
+		const { nextLevel } = await import("./detect.ts");
+		return nextLevel(state.consecutiveDetections, config);
+	}
+
+	/**
+	 * Force break: steer a real user message into the running agent. pi delivers
+	 * "steer" messages right after the current tool results and BEFORE the next
+	 * LLM call — the model must respond to it, which breaks the identical-context
+	 * anchoring that verbatim loops feed on. (before_agent_start injection was
+	 * abandoned: it only fires on the NEXT user prompt, never mid-run — the exact
+	 * reason antiloop previously failed to cut autonomous tool loops.)
+	 */
+	function deliverForceBreak(ctx: ExtensionContext, detections: LoopDetection[]): void {
+		const detail = detections[0]?.description ?? "repeated message/tool calls";
+		try {
+			pi.sendUserMessage(
+				`[antiloop] 🛑 Force break — loop detected (${detail}; ${state.consecutiveDetections} consecutive).\n` +
+					"Stop repeating previous text, reasoning and tool calls, and change approach now.\n" +
+					"If you cannot make progress with a different approach, do NOT call more tools — " +
+					"reply to the user briefly: what you tried, what is blocking you, and what you need.",
+				{ deliverAs: "steer" },
+			);
+			state.steerDelivered = true;
+			if (config.notifyOnDetection) {
+				ctx.ui.notify(`antiloop: force break — ${detail} (break message sent to the model)`, "error");
+			}
+		} catch (err) {
+			// Steer could not be queued (edge: run ended between detection and queue).
+			// Stay armed so the next steerable turn delivers the break.
+			state.steerDelivered = false;
+			if (config.notifyOnDetection) {
+				ctx.ui.notify(
+					`antiloop: force break — ${detail} (could not inject: ${err instanceof Error ? err.message : String(err)})`,
+					"error",
+				);
 			}
-			return;
 		}
-		state.consecutiveDetections++;
-		state.totalDetections++;
-		state.detections.push(...detections);
-		if (state.detections.length > config.maxHistoryEntries) state.detections = state.detections.slice(-config.maxHistoryEntries);
-
-		let next: 0 | 1 | 2 | 3 = 0;
-		if (state.consecutiveDetections >= config.abortThreshold && config.abortThreshold > 0) next = 3;
-		else if (state.consecutiveDetections >= config.forceBreakThreshold) next = 2;
-		else if (state.consecutiveDetections >= config.warningThreshold) next = 1;
-		if (next > state.currentLevel) state.currentLevel = next;
-
-		// 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;
+	}
+
+	/**
+	 * Hard stop: abort the current agent run (fire-and-forget — never awaited, so
+	 * the turn_end handler cannot deadlock on waitForIdle) and tell the user.
+	 */
+	function hardStop(ctx: ExtensionContext, text: string): void {
+		try {
+			ctx.abort();
+		} catch {
+			// abort must never throw out of a hook.
+		}
+		if (config.notifyOnDetection) {
+			ctx.ui.notify(text, "error");
 		}
 	}
 
@@ -222,44 +263,29 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		}
 	});
 
-	pi.on("input", async () => {
+	pi.on("input", async (event) => {
 		if (!config.enabled) return;
+		// Messages queued by extensions (including antiloop's own force-break
+		// steer) are NOT user input: they must not cool down the escalation or
+		// re-arm the steer — that would defeat the force break.
+		const source = (event as { source?: string } | undefined)?.source;
+		if (source === "extension") return { action: "continue" };
+
 		state.lastUserMessageTime = Date.now();
-		if (state.consecutiveDetections > 0) state.consecutiveDetections = Math.max(0, state.consecutiveDetections - 2);
-		if (state.consecutiveDetections < config.warningThreshold) {
-			state.currentLevel = 0;
-			state.inForcedBreak = false;
+		if (state.consecutiveDetections > 0) {
+			state.consecutiveDetections = Math.max(0, state.consecutiveDetections - 2);
 		}
+		// A real user message is a new chance: mirror the level off the cooled-down
+		// counter and re-arm the force break so a fresh loop gets a fresh steer.
+		applyLevel(await levelForConsecutive());
+		state.steerDelivered = false;
+		state.ignoredSteerCount = 0;
 		return { action: "continue" };
 	});
 
-	pi.on("before_agent_start", async () => {
-		if (!config.enabled || !rt.pendingIntervention) return;
-		const msg = rt.pendingIntervention;
-		rt.pendingIntervention = null;
-		return {
-			message: { customType: "antiloop-intervention", content: msg, display: true },
-		};
-	});
-
-	pi.on("context", async (event) => {
-		if (!config.enabled || state.currentLevel < 2) return;
-		const msgs = [...event.messages];
-		for (let i = msgs.length - 1; i >= 0; i--) {
-			if (msgs[i].role === "assistant") {
-				const m = msgs[i] as { content: string | Array<{ type: string; text?: string }> };
-				const inject = "\n\n[antiloop] break out of loop — try a different approach.";
-				if (typeof m.content === "string") m.content += inject;
-				else if (Array.isArray(m.content)) m.content.push({ type: "text", text: inject });
-				break;
-			}
-		}
-		return { messages: msgs };
-	});
-
 	pi.on("turn_end", async (event, ctx) => {
 		if (!config.enabled) return;
-		const { detectLoops, detectTaskStreams, interventionMessage, resultFingerprint } = await import("./detect.ts");
+		const { detectLoops, detectTaskStreams, isVerbatimRepeat, nextLevel, resultFingerprint } = await import("./detect.ts");
 
 		const last = state.recentMessages[state.recentMessages.length - 1];
 		if (!last || last.turnIndex === state.lastDetectedTurnIndex) {
@@ -288,12 +314,66 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		).map(([tool, count]) => ({ tool, count }));
 
 		const detections = detectLoops(state, config);
-		processDetections(detections, interventionMessage);
+		const prevLevel = state.currentLevel;
 
-		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");
+		// ---- clean turn: cool down ----------------------------------------
+		if (!detections.length) {
+			if (state.consecutiveDetections > 0) state.consecutiveDetections--;
+			applyLevel(nextLevel(state.consecutiveDetections, config));
+			if (state.currentLevel === 0) {
+				state.steerDelivered = false;
+				state.ignoredSteerCount = 0;
+			}
+			updateStatus(ctx);
+			return;
 		}
+
+		// ---- detection: escalate ------------------------------------------
+		state.consecutiveDetections++;
+		state.totalDetections++;
+		state.detections.push(...detections);
+		if (state.detections.length > config.maxHistoryEntries) {
+			state.detections = state.detections.slice(-config.maxHistoryEntries);
+		}
+		applyLevel(nextLevel(state.consecutiveDetections, config));
+		const level = state.currentLevel;
+
+		// The steer is only picked up when the run keeps going after this turn.
+		// On error/aborted stop reasons the agent loop returns immediately and the
+		// queued message would go stale — stay armed and steer on a later turn.
+		const stopReason = (event as { message?: { stopReason?: string } } | undefined)?.message?.stopReason;
+		const steerable = stopReason !== "error" && stopReason !== "aborted" && ctx.signal !== undefined;
+
+		if (level === 1 && prevLevel < 1) {
+			// Warning: informational only (never injects — a warning must not stall).
+			if (config.notifyOnDetection) {
+				ctx.ui.notify(`antiloop: warning — ${detections[0].description}`, "warning");
+			}
+		} else if (level === 2) {
+			if (!state.steerDelivered) {
+				// First force-break turn of the episode: steer a break message
+				// before the next LLM call.
+				if (steerable) {
+					deliverForceBreak(ctx, detections);
+				} else if (prevLevel < 2 && config.notifyOnDetection) {
+					ctx.ui.notify(`antiloop: force break — ${detections[0].description}`, "error");
+				}
+			} else if (isVerbatimRepeat(detections)) {
+				// The model repeated the same message/call after being told to stop:
+				// count it; once the ignore limit is hit the run is cut for good.
+				state.ignoredSteerCount++;
+				if (state.ignoredSteerCount >= config.ignoredSteerLimit) {
+					hardStop(
+						ctx,
+						`antiloop: abort — the model repeated the same message ${state.ignoredSteerCount}× after the force break — run stopped; provide new instructions`,
+					);
+				}
+			}
+		} else if (level === 3) {
+			// abortThreshold configured and reached: stop the run outright.
+			hardStop(ctx, `antiloop: abort — ${detections[0].description} — run stopped; provide new instructions`);
+		}
+
 		updateStatus(ctx);
 	});
 
@@ -301,7 +381,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		// re-read config and reset state for a fresh session
 		Object.assign(config, loadConfig());
 		state = newState();
-		rt.pendingIntervention = null;
 		installFooter(ctx);
 		updateStatus(ctx);
 	});

package/src/types.ts

@@ -7,6 +7,15 @@ export interface AntiloopConfig {
 	forceBreakThreshold: number;
 	abortThreshold: number;
 	similarityThreshold: number;
+	/**
+	 * How many ESSENTIALLY IDENTICAL repeats (≥98% similar text / identical tool
+	 * loops) the model may produce AFTER the force-break message before antiloop
+	 * hard-stops the run (ctx.abort). Guards the force break: if the model ignores
+	 * the break instruction and keeps repeating verbatim, the run is cut instead of
+	 * burning context forever. Only verbatim repeats count — a model that changes
+	 * its output (even while still similar) gets room to escape on its own.
+	 */
+	ignoredSteerLimit: 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,
@@ -107,12 +116,18 @@ export interface AntiloopState {
 	lastUserMessageTime: number;
 	/** turnIndex of the last tracked message detection already ran on. */
 	lastDetectedTurnIndex: number;
+	/** True once the force-break user message was steered into the current episode.
+	 * One steer per episode: repeated steering would spam the conversation. Cleared
+	 * when the episode decays (currentLevel back to 0) or on real user input. */
+	steerDelivered: boolean;
+	/** Verbatim repeats counted AFTER the steer. When this reaches
+	 * config.ignoredSteerLimit the run is hard-stopped (aborted). */
+	ignoredSteerCount: number;
 }
 
 export interface Runtime {
 	config: AntiloopConfig;
 	state: AntiloopState;
-	pendingIntervention: string | null;
 	updateStatus(ctx: ExtensionContext): void;
 	/** Re-install the interactive footer (after config changes). */
 	refreshFooter?(ctx: ExtensionContext): void;