pi-antiloop 1.3.1 → 1.4.0

package/README.md

@@ -106,23 +106,35 @@ Recent detections:
 
 ### `/antiloop config`
 
-Interactive menu with current values:
-
-- **Enable/disable**
-- **Warning threshold** — similar messages before warning (default 2)
-- **Force break threshold** — similar messages before force break (default 3)
-- **Abort threshold** — similar messages before abort (0 = disabled)
-- **Similarity threshold** — `0.5 / 0.6 / 0.7 / 0.75 / 0.8 / 0.9` — how close two messages must be to count as looping
-- **Tool similarity** — `0.99 / 0.95 / 0.9 / 0.8` — how close tool-call *arguments* must be to count as the same call (95% default: only near-identical repeats loop)
-- **Tool repeat** — `1 / 2 / 3` — prior occurrences of the same call set required before a tool loop flags
-- **Result similarity** — `0.95 / 0.8 / 0.6` — how similar captured results must be to count as the *same outcome* (veto when a repeated command starts succeeding/differing)
-- **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
-- **Reset state** — clear all counters and history
+Menú interactivo agrupado, con el valor actual en cada opción:
+
+**🎛️ 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
 
 ### `/antiloop log`
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antiloop",
-  "version": "1.3.1",
+  "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.",
   "keywords": [
     "pi-package",

package/src/commands.ts

@@ -76,26 +76,31 @@ async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<vo
 
 async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promise<void> {
 	const c = rt.config;
-	const picked = await selectFrom(ctx, "antiloop config", [
-		{ value: "toggle" as const, label: c.enabled ? "🟢 disable" : "🔴 enable", description: "toggle detection" },
-		{ value: "warn" as const, label: `warn threshold: ${c.warningThreshold}` },
-		{ value: "force" as const, label: `force threshold: ${c.forceBreakThreshold}` },
-		{ value: "abort" as const, label: `abort threshold: ${c.abortThreshold || "off"}`, description: "0 = disabled" },
-		{ value: "sim" as const, label: `similarity: ${(c.similarityThreshold * 100).toFixed(0)}%` },
-		{ value: "toolSim" as const, label: `tool similarity: ${(c.toolSimilarityThreshold * 100).toFixed(0)}%`, description: "args must match this closely to count as the same call" },
-		{ value: "toolRepeat" as const, label: `tool repeat: ${c.minToolRepeatCount}+ prior`, description: "recurrences before a tool loop flags" },
-		{ value: "resultSim" as const, label: `result similarity: ${(c.resultSimilarityThreshold * 100).toFixed(0)}%`, description: "same cmd + different outcome vetoes the loop" },
-		{ value: "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" },
+	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" },
+		// ── 📋 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: "reset" as const, label: "🧹 reiniciar estado", description: "borra contadores e historial" },
 	]);
 	if (!picked) return;
 	switch (picked) {
@@ -105,139 +110,139 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 			ctx.ui.notify(`antiloop: ${c.enabled ? "ON" : "OFF"}`, "info");
 			rt.updateStatus(ctx);
 			break;
+		case "window": {
+			const v = await selectFrom(ctx, "⏳ ventana (mensajes a analizar)", [
+				{ value: 5, label: "5" },
+				{ value: 10, label: "10 (por defecto)" },
+				{ value: 15, label: "15" },
+				{ value: 20, label: "20" },
+			]);
+			if (v !== undefined) { c.detectionWindow = v; saveConfig(c); ctx.ui.notify(`ventana: ${v}`, "info"); }
+			break;
+		}
+		case "notify":
+			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
+			ctx.ui.notify(`avisos: ${yn(c.notifyOnDetection)}`, "info"); break;
+		case "footer":
+			c.interactiveFooter = !c.interactiveFooter; saveConfig(c);
+			ctx.ui.notify(`pie interactivo: ${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" },
+			]);
+			if (v !== undefined) { c.toggleShortcut = v; saveConfig(c); rt.refreshFooter?.(ctx); ctx.ui.notify(`atajo: ${v}`, "info"); }
+			break;
+		}
 		case "warn": {
-			const v = await selectFrom(ctx, "warn threshold", [
-				{ value: 1, label: "1 (sensitive)" },
-				{ value: 2, label: "2 (default)" },
+			const v = await selectFrom(ctx, "⚠️ umbral de aviso", [
+				{ value: 1, label: "⚡ 1 (sensible)" },
+				{ value: 2, label: "🎯 2 (por defecto)" },
 				{ value: 3, label: "3" },
-				{ value: 5, label: "5 (relaxed)" },
+				{ value: 5, label: "🐢 5 (relajado)" },
 			]);
-			if (v !== undefined) { c.warningThreshold = v; saveConfig(c); ctx.ui.notify(`warn: ${v}`, "info"); }
+			if (v !== undefined) { c.warningThreshold = v; saveConfig(c); ctx.ui.notify(`aviso: ${v}`, "info"); }
 			break;
 		}
 		case "force": {
-			const v = await selectFrom(ctx, "force threshold", [
-				{ value: 2, label: "2 (sensitive)" },
-				{ value: 3, label: "3 (default)" },
+			const v = await selectFrom(ctx, "🛑 umbral de corte", [
+				{ value: 2, label: "⚡ 2 (sensible)" },
+				{ value: 3, label: "🎯 3 (por defecto)" },
 				{ value: 5, label: "5" },
-				{ value: 8, label: "8 (relaxed)" },
+				{ value: 8, label: "🐢 8 (relajado)" },
 			]);
-			if (v !== undefined) { c.forceBreakThreshold = v; saveConfig(c); ctx.ui.notify(`force: ${v}`, "info"); }
+			if (v !== undefined) { c.forceBreakThreshold = v; saveConfig(c); ctx.ui.notify(`corte: ${v}`, "info"); }
 			break;
 		}
 		case "abort": {
-			const v = await selectFrom(ctx, "abort threshold (0=off)", [
-				{ value: 0, label: "off" },
+			const v = await selectFrom(ctx, "🚨 umbral de aborto (0 = desactivado)", [
+				{ value: 0, label: "🚫 desactivado" },
 				{ value: 5, label: "5" },
 				{ value: 8, label: "8" },
 				{ value: 10, label: "10" },
 				{ value: 15, label: "15" },
 			]);
-			if (v !== undefined) { c.abortThreshold = v; saveConfig(c); ctx.ui.notify(`abort: ${v || "off"}`, "info"); }
+			if (v !== undefined) { c.abortThreshold = v; saveConfig(c); ctx.ui.notify(`aborto: ${v || "desactivado"}`, "info"); }
 			break;
 		}
 		case "sim": {
-			const v = await selectFrom(ctx, "similarity", [
-				{ value: 0.5, label: "50% (sensitive)" },
+			const v = await selectFrom(ctx, "📏 parecido mínimo entre mensajes", [
+				{ value: 0.5, label: "⚡ 50% (sensible)" },
 				{ value: 0.6, label: "60%" },
 				{ value: 0.7, label: "70%" },
-				{ value: 0.75, label: "75% (default)" },
+				{ value: 0.75, label: "🎯 75% (por defecto)" },
 				{ value: 0.8, label: "80%" },
-				{ value: 0.9, label: "90% (relaxed)" },
+				{ value: 0.9, label: "🐢 90% (relajado)" },
 			]);
-			if (v !== undefined) { c.similarityThreshold = v; saveConfig(c); ctx.ui.notify(`similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			if (v !== undefined) { c.similarityThreshold = v; saveConfig(c); ctx.ui.notify(`parecido: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
 		case "toolSim": {
-			const v = await selectFrom(ctx, "tool similarity (args)", [
-				{ value: 0.99, label: "99% (strict)" },
-				{ value: 0.95, label: "95% (default)" },
+			const v = await selectFrom(ctx, "🔧 parecido de las llamadas (argumentos)", [
+				{ value: 0.99, label: "⚡ 99% (estricto)" },
+				{ value: 0.95, label: "🎯 95% (por defecto)" },
 				{ value: 0.9, label: "90%" },
-				{ value: 0.8, label: "80% (sensitive)" },
+				{ value: 0.8, label: "🐢 80% (sensible)" },
 			]);
-			if (v !== undefined) { c.toolSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`tool similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			if (v !== undefined) { c.toolSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`parecido de llamadas: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
 		case "toolRepeat": {
-			const v = await selectFrom(ctx, "tool repeat (prior occurrences)", [
-				{ value: 1, label: "1 (sensitive)" },
-				{ value: 2, label: "2 (default)" },
-				{ value: 3, label: "3 (relaxed)" },
+			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)" },
 			]);
-			if (v !== undefined) { c.minToolRepeatCount = v; saveConfig(c); ctx.ui.notify(`tool repeat: ${v}+ prior`, "info"); }
+			if (v !== undefined) { c.minToolRepeatCount = v; saveConfig(c); ctx.ui.notify(`repeticiones: ${v}+`, "info"); }
 			break;
 		}
 		case "resultSim": {
-			const v = await selectFrom(ctx, "result similarity (outcome veto)", [
-				{ value: 0.95, label: "95% (strict — only near-identical results count as same outcome)" },
-				{ value: 0.8, label: "80% (default)" },
-				{ value: 0.6, label: "60% (relaxed — tolerates more output noise)" },
+			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)" },
 			]);
-			if (v !== undefined) { c.resultSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`result similarity: ${(v * 100).toFixed(0)}%`, "info"); }
+			if (v !== undefined) { c.resultSimilarityThreshold = v; saveConfig(c); ctx.ui.notify(`parecido de resultados: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
 		case "streams":
 			c.detectTaskStreams = !c.detectTaskStreams; saveConfig(c);
-			ctx.ui.notify(`task streams: ${yn(c.detectTaskStreams)}`, "info"); break;
+			ctx.ui.notify(`lotes de tareas: ${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)" },
+			const v = await selectFrom(ctx, "📋 llamadas mínimas para reconocer un lote", [
+				{ value: 2, label: "⚡ 2 (sensible)" },
+				{ value: 3, label: "🎯 3 (por defecto)" },
 				{ value: 4, label: "4" },
-				{ value: 5, label: "5 (conservative)" },
+				{ value: 5, label: "🐢 5 (conservador)" },
 			]);
-			if (v !== undefined) { c.taskStreamMinCalls = v; saveConfig(c); ctx.ui.notify(`stream min calls: ${v}`, "info"); }
+			if (v !== undefined) { c.taskStreamMinCalls = v; saveConfig(c); ctx.ui.notify(`llamadas mínimas: ${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)" },
+			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)" },
 			]);
-			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" },
-				{ value: 10, label: "10 (default)" },
-				{ value: 15, label: "15" },
-				{ value: 20, label: "20" },
-			]);
-			if (v !== undefined) { c.detectionWindow = v; saveConfig(c); ctx.ui.notify(`window: ${v}`, "info"); }
+			if (v !== undefined) { c.taskStreamTwinThreshold = v; saveConfig(c); ctx.ui.notify(`gemelos: ${(v * 100).toFixed(0)}%`, "info"); }
 			break;
 		}
 		case "text":
 			c.detectTextLoops = !c.detectTextLoops; saveConfig(c);
-			ctx.ui.notify(`text: ${yn(c.detectTextLoops)}`, "info"); break;
+			ctx.ui.notify(`texto: ${yn(c.detectTextLoops)}`, "info"); break;
 		case "tool":
 			c.detectToolLoops = !c.detectToolLoops; saveConfig(c);
-			ctx.ui.notify(`tool: ${yn(c.detectToolLoops)}`, "info"); break;
+			ctx.ui.notify(`herramientas: ${yn(c.detectToolLoops)}`, "info"); break;
 		case "think":
 			c.detectThinkingLoops = !c.detectThinkingLoops; saveConfig(c);
-			ctx.ui.notify(`think: ${yn(c.detectThinkingLoops)}`, "info"); break;
-		case "notify":
-			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
-			ctx.ui.notify(`notify: ${yn(c.notifyOnDetection)}`, "info"); break;
-		case "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;
-		}
+			ctx.ui.notify(`pensamiento: ${yn(c.detectThinkingLoops)}`, "info"); break;
 		case "reset":
 			resetState(rt.state);
 			rt.pendingIntervention = null;
-			ctx.ui.notify("reset", "info");
+			ctx.ui.notify("🧹 estado reiniciado", "info");
 			rt.updateStatus(ctx);
 			break;
 	}
@@ -245,7 +250,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 detections this session", "info");
+		ctx.ui.notify("no hay detecciones en esta sesión", "info");
 		return;
 	}
 	const items = rt.state.detections.slice(-30).reverse().map((d) => ({
@@ -253,7 +258,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, `detections (${rt.state.detections.length} total)`, items);
+	await selectFrom(ctx, `🕵️ detecciones (${rt.state.detections.length} en total)`, items);
 }
 
 export function resetState(state: AntiloopState): void {

package/src/detect.ts

@@ -59,11 +59,19 @@ function similarity(a: string, b: string): number {
  * Stable against PID / timestamp noise at the tail of command output.
  */
 export function resultFingerprint(
-	parts: Array<{ type: string; text?: string }>,
+	parts: unknown,
 	isError: boolean,
 ): string | undefined {
 	let text = "";
-	for (const p of parts) if (p.type === "text" && typeof p.text === "string") text += p.text;
+	if (typeof parts === "string") {
+		text = parts;
+	} else if (Array.isArray(parts)) {
+		for (const p of parts) {
+			if (p && typeof p === "object" && "type" in p && p.type === "text" && typeof (p as any).text === "string") {
+				text += (p as any).text;
+			}
+		}
+	}
 	const norm = normalizeText(text);
 	if (!norm.length) return undefined;
 	return `${isError ? "err" : "ok"}|${norm.slice(-400)}`;
@@ -72,9 +80,6 @@ export function resultFingerprint(
 /** Same outcome = identical fingerprint, or high similarity of the tails. */
 function sameOutcome(a: string, b: string, threshold: number): boolean {
 	if (a === b) return true;
-	// Fingerprints are already normalized + capped, so short ones can be
-	// compared with edit distance directly — similarity() bails under 50 chars
-	// and would wrongly veto small outputs with harmless noise (PIDs, times).
 	if (a.length < 100 && b.length < 100) {
 		const max = Math.max(a.length, b.length);
 		const s = max ? 1 - levenshtein(a, b) / max : 1;
@@ -91,14 +96,10 @@ function toolCallsSimilar(
 	resultThreshold: number,
 ): boolean {
 	if (c1.length !== c2.length) return false;
-	// Empty call lists carry no repetition evidence — never treat them as a match.
 	if (!c1.length) return false;
 	for (let i = 0; i < c1.length; i++) {
 		if (c1[i].name !== c2[i].name) return false;
-		if (similarity(c1[i].args, c2[i].args) < threshold) return false;
-		// Result veto: the same command producing a different outcome is
-		// progress (a retry that fixed the problem), not a loop. Only applies
-		// when both runs actually captured a result.
+		if (!argsTwin(c1[i].args, c2[i].args, threshold)) return false;
 		const r1 = c1[i].result;
 		const r2 = c2[i].result;
 		if (r1 && r2 && !sameOutcome(r1, r2, resultThreshold)) {
@@ -220,7 +221,7 @@ export function detectLoops(state: AntiloopState, config: AntiloopConfig): LoopD
 				const last = opens[opens.length - 1].o;
 				let n = 0;
 				for (let i = 0; i < opens.length - 1; i++) {
-					if (similarity(last, opens[i].o) > 0.9) n++;
+					if (argsTwin(last, opens[i].o, 0.9)) n++;
 				}
 				if (n >= 2 && !allBatch([msgs.length - 1])) {
 					out.push({

package/src/index.ts

@@ -109,14 +109,12 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 	function installFooter(ctx: ExtensionContext): void {
 		if (!config.interactiveFooter || ctx.mode !== "tui") {
 			ctx.ui.setFooter(undefined);
+			activeTui = 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 =
@@ -128,12 +126,13 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 								pendingEsc = true;
 								return undefined;
 							}
-							if (pendingEsc && data === "a") {
+							if (pendingEsc) {
 								pendingEsc = false;
-								toggleEnabled(ctx);
+								if (data === "a") {
+									toggleEnabled(ctx);
+								}
 								return undefined;
 							}
-							pendingEsc = false;
 							return undefined;
 					  });
 
@@ -146,7 +145,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 				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 =
@@ -155,7 +153,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 							: 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}` : "";
@@ -167,7 +164,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 						);
 					}
 
-					// Line 3: built-in footer data preserved (dim).
 					let info = formatCwd(ctx.cwd);
 					const branch = footerData.getGitBranch();
 					if (branch) info += ` (${branch})`;
@@ -177,7 +173,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 					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);
@@ -206,7 +201,6 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 			}
 		}
 
-		// Track the call with its id so turn_end can attach the execution result.
 		const toolCalls: TrackedToolCall[] = [];
 		if (Array.isArray(msg.content)) {
 			for (const p of msg.content) {
@@ -268,19 +262,13 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		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)
-		// must not re-run detection on the previous message — skip it.
 		if (!last || last.turnIndex === state.lastDetectedTurnIndex) {
 			updateStatus(ctx);
 			return;
 		}
 		state.lastDetectedTurnIndex = last.turnIndex;
 
-		// Attach execution results to the message that just finished its turn.
-		// Detection runs here (not at message_end) because the results — the
-		// signal that distinguishes "stuck loop" from "making progress" — only
-		// exist after the tools have executed.
-		if (last.toolCalls?.length && event.toolResults.length) {
+		if (last.toolCalls?.length && Array.isArray(event?.toolResults)) {
 			const byId = new Map<string, string | undefined>();
 			for (const tr of event.toolResults) byId.set(tr.toolCallId, resultFingerprint(tr.content, tr.isError));
 			for (const tc of last.toolCalls) {