pi-antiloop 1.1.0 → 1.2.0

package/README.md

@@ -16,7 +16,7 @@
 - **Progressive intervention** — `warning` reminds the model to vary its approach; `force break` injects explicit anti-loop instructions and modifies context; `abort` stops the run entirely
 - **Configurable thresholds** — independent dials for similarity cutoff, warning/force-break/abort counts, detection window, and which strategies are on
 - **Sliding window** — only the last N messages are compared, so detection is O(N) in the window size, not in the full session
-- **Live status bar** — `🔄 antiloop`, `⚠️ antiloop(N)`, `🛑 antiloop(N)`, `🚨 antiloop(N)` reflect the current intervention level
+- **Live footer indicator** — `🔄 antiloop(on|off)` in the footer, per spec, with the current level (`⚠️/🛑/🚨`) and consecutive count; an interactive TUI footer adds a keyboard toggle (`esc+a` by default, configurable/off) and preserves the built-in footer's pwd/branch/context/model info
 - **Detection log** — timestamped history with similarity scores, filterable through the native pi menu
 - **Self-test** — `/antiloop test` runs built-in cases to verify the similarity engine is calibrated
 - **User input softens detection** — each new user message decays the consecutive counter so a fresh prompt can resolve the loop without manual reset
@@ -161,7 +161,7 @@ Each detected pair becomes a `LoopDetection { type, similarity, messageIndices,
 | Level | Trigger | Behavior |
 |-------|---------|----------|
 | 0 (no loop) | — | Silent — passes the message through |
-| 1 (warning) | `consecutiveDetections >= warningThreshold` | Injects a soft reminder asking the model to vary its approach |
+| 1 (warning) | `consecutiveDetections >= warningThreshold` | Notifies the user (`⚠️`) — no message is injected into the conversation, so the model's generation is never interrupted by the warning itself |
 | 2 (force break) | `consecutiveDetections >= forceBreakThreshold` | Injects mandatory anti-loop instructions + appends a context message to the last assistant message |
 | 3 (abort) | `consecutiveDetections >= abortThreshold` | (Disabled by default) Surfaces an error asking the user for new instructions |
 
@@ -231,7 +231,9 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
   "detectTextLoops": true,
   "notifyOnDetection": true,
   "maxHistoryEntries": 100,
-  "detectionWindow": 10
+  "detectionWindow": 10,
+  "interactiveFooter": true,
+  "toggleShortcut": "esc+a"
 }
 ```
 
@@ -251,6 +253,8 @@ Persisted as JSON at `~/.pi/agent/antiloop.json`:
 | `notifyOnDetection` | `true` | Show a notification on every detection |
 | `maxHistoryEntries` | `100` | Max detection history entries |
 | `detectionWindow` | `10` | Number of recent messages to analyze |
+| `interactiveFooter` | `true` | TUI footer replaces the built-in one with an antiloop indicator + toggle shortcut (set `false` to keep the built-in footer and only the `setStatus` line) |
+| `toggleShortcut` | `esc+a` | Key sequence that toggles antiloop from the footer (`esc+a` or `off`). The input is never consumed, so typing is unaffected |
 
 ## Best Practices
 
@@ -286,8 +290,8 @@ Modular extension with zero external dependencies (only pi's bundled `@earendil-
 - **Levenshtein + trigram Jaccard** hybrid — small texts use edit distance, large texts use n-gram overlap (each is O(N) in text length)
 - **Sliding window** — only the last `detectionWindow` messages participate, capping memory at O(W × message_size)
 - **Early bail** — short messages and empty tool calls skip similarity computation entirely
-- **TUI integration** — uses `ctx.ui.select` for the config menu and the log viewer; `ctx.ui.notify` for state notifications; `ctx.ui.setStatus` for the persistent status bar
-- **Hooks** — `message_end` (track messages + tool call ids), `turn_end` (attach result fingerprints + detect), `input` (decay), `before_agent_start` (inject intervention), `context` (modify context in force-break mode), `session_start` (load config + reset)
+- **TUI integration** — uses `ctx.ui.select` for the config menu and the log viewer; `ctx.ui.notify` for state notifications; `ctx.ui.setStatus` + a custom `ctx.ui.setFooter` component for the persistent footer indicator, live level info, and the `esc+a` keyboard toggle (`ctx.ui.onTerminalInput`, never consumes input)
+- **Hooks** — `message_end` (track messages + tool call ids), `turn_end` (attach result fingerprints + detect), `input` (decay), `before_agent_start` (inject intervention — force/abort only), `context` (modify context in force-break mode), `session_start` (load config + install footer + reset), `session_shutdown` (restore built-in footer)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-antiloop",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Antiloop: detect reasoning loops and force a break (warn → force → abort) across text, tool, thinking, and structural patterns. Tool-loop detection is result-aware: only near-identical repeated calls with the same outcome count, so sequential bash operations and retries that make progress don't false-positive.",
   "keywords": [
     "pi-package",

package/src/commands.ts

@@ -61,6 +61,7 @@ async function showStatus(ctx: ExtensionCommandContext, rt: Runtime): Promise<vo
 		`  result sim: ${(rt.config.resultSimilarityThreshold * 100).toFixed(0)}%  (same cmd + diff outcome = no loop)`,
 		"",
 		`detectors: text ${yn(rt.config.detectTextLoops)} · tool ${yn(rt.config.detectToolLoops)} · think ${yn(rt.config.detectThinkingLoops)}`,
+		`footer: interactive ${yn(rt.config.interactiveFooter)} · toggle: ${rt.config.toggleShortcut}`,
 	];
 	if (recent.length) {
 		lines.push("", "recent:");
@@ -85,6 +86,8 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 		{ value: "tool" as const, label: `tool detect: ${yn(c.detectToolLoops)}` },
 		{ value: "think" as const, label: `think detect: ${yn(c.detectThinkingLoops)}` },
 		{ value: "notify" as const, label: `notify: ${yn(c.notifyOnDetection)}` },
+		{ value: "footer" as const, label: `interactive footer: ${yn(c.interactiveFooter)}`, description: "TUI footer with toggle shortcut" },
+		{ value: "shortcut" as const, label: `toggle shortcut: ${c.toggleShortcut}`, description: "esc+a or off" },
 		{ value: "reset" as const, label: "reset state" },
 	]);
 	if (!picked) return;
@@ -188,6 +191,20 @@ async function showConfigMenu(ctx: ExtensionCommandContext, rt: Runtime): Promis
 		case "notify":
 			c.notifyOnDetection = !c.notifyOnDetection; saveConfig(c);
 			ctx.ui.notify(`notify: ${yn(c.notifyOnDetection)}`, "info"); break;
+		case "footer":
+			c.interactiveFooter = !c.interactiveFooter; saveConfig(c);
+			ctx.ui.notify(`interactive footer: ${yn(c.interactiveFooter)}`, "info");
+			rt.refreshFooter?.(ctx);
+			rt.updateStatus(ctx);
+			break;
+		case "shortcut": {
+			const v = await selectFrom(ctx, "toggle shortcut", [
+				{ value: "esc+a" as const, label: "esc+a (default)", description: "press ESC then a to toggle" },
+				{ value: "off" as const, label: "off", description: "disable keyboard toggle" },
+			]);
+			if (v !== undefined) { c.toggleShortcut = v; saveConfig(c); rt.refreshFooter?.(ctx); ctx.ui.notify(`toggle shortcut: ${v}`, "info"); }
+			break;
+		}
 		case "reset":
 			resetState(rt.state);
 			rt.pendingIntervention = null;

package/src/config.ts

@@ -22,6 +22,8 @@ export const DEFAULT_CONFIG: AntiloopConfig = {
 	notifyOnDetection: true,
 	maxHistoryEntries: 100,
 	detectionWindow: 10,
+	interactiveFooter: true,
+	toggleShortcut: "esc+a",
 };
 
 export function getConfigPath(): string {

package/src/index.ts

@@ -1,14 +1,16 @@
 /**
  * antiloop — detect reasoning loops and intervene.
- * Hooks: message_end, input, before_agent_start, context, turn_end, session_start.
+ * Hooks: message_end, input, before_agent_start, context, turn_end, session_start, session_shutdown.
  * Commands: /antiloop [enable|disable|status|config|log|reset|test]
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { loadConfig } from "./config.ts";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { loadConfig, saveConfig } from "./config.ts";
 import type { AntiloopState, LoopDetection, Runtime, TrackedToolCall } from "./types.ts";
 
 const ICONS = ["", "⚠️", "🛑", "🚨"] as const;
+const LEVEL_NAMES = ["", "warning", "force", "abort"] as const;
 
 function newState(): AntiloopState {
 	return {
@@ -23,22 +25,50 @@ function newState(): AntiloopState {
 	};
 }
 
+/** Compact pwd: ~-relative when inside $HOME, with trailing separator trimmed. */
+function formatCwd(cwd: string): string {
+	const home = process.env.HOME;
+	if (home && cwd.startsWith(home)) {
+		const rel = cwd.slice(home.length).replace(/^[/\\]+/, "");
+		return rel ? `~/${rel}` : "~";
+	}
+	return cwd;
+}
+
 export default function antiloopExtension(pi: ExtensionAPI) {
 	const config = loadConfig();
 	let state = newState();
 
+	/** TUI handle for forcing footer re-renders (set by the footer factory). */
+	let activeTui: { requestRender(force?: boolean): void } | undefined;
+
+	/** Status text shown in the footer: "(emoji_antiloop)(on/off)" per spec. */
+	function antiloopStatusText(): string {
+		if (!config.enabled) return "🔄 antiloop(off)";
+		if (state.currentLevel === 0) return "🔄 antiloop(on)";
+		return `${ICONS[state.currentLevel]} antiloop(on)×${state.consecutiveDetections}`;
+	}
+
 	function updateStatus(ctx: ExtensionContext): void {
-		if (!config.enabled) ctx.ui.setStatus("antiloop", undefined);
-		else if (state.currentLevel === 0) ctx.ui.setStatus("antiloop", "🔄 antiloop");
-		else ctx.ui.setStatus("antiloop", `${ICONS[state.currentLevel]} antiloop(${state.consecutiveDetections})`);
+		// Always set a status line so the footer shows on/off either way.
+		ctx.ui.setStatus("antiloop", antiloopStatusText());
+		activeTui?.requestRender();
 	}
 
-	const rt: Runtime = { config, state, pendingIntervention: null, updateStatus };
+	const rt: Runtime = { config, state, pendingIntervention: null, updateStatus, refreshFooter: installFooter };
 	const setPending = (v: string | null) => { rt.pendingIntervention = v; };
 
+	/** Toggle enable/disable, persisting config and refreshing the footer. */
+	function toggleEnabled(ctx: ExtensionContext): void {
+		config.enabled = !config.enabled;
+		saveConfig(config);
+		ctx.ui.notify(`antiloop: ${config.enabled ? "ON" : "OFF"}`, "info");
+		updateStatus(ctx);
+	}
+
 	function processDetections(
 		detections: LoopDetection[],
-		interventionMessage: (level: 1 | 2 | 3, d: LoopDetection[]) => string,
+		interventionMessage: (level: 2 | 3, d: LoopDetection[]) => string,
 	): void {
 		if (!detections.length) {
 			if (state.consecutiveDetections > 0) state.consecutiveDetections = Math.max(0, state.consecutiveDetections - 1);
@@ -59,12 +89,109 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		else if (state.consecutiveDetections >= config.warningThreshold) next = 1;
 		if (next > state.currentLevel) state.currentLevel = next;
 
-		if (state.currentLevel > 0) {
-			setPending(interventionMessage(state.currentLevel as 1 | 2 | 3, detections));
-			state.inForcedBreak = state.currentLevel >= 2;
+		// Warning (level 1) is informational only: notify the user but DO NOT
+		// inject any message into the conversation. Injecting at warning level
+		// made the model respond to the warning, which could stall generation
+		// even though hard-kill turns remained. Only force (2) / abort (3) inject.
+		if (state.currentLevel >= 2) {
+			setPending(interventionMessage(state.currentLevel as 2 | 3, detections));
+			state.inForcedBreak = true;
+		} else if (state.currentLevel === 1) {
+			state.inForcedBreak = false;
 		}
 	}
 
+	// ------------------------------------------------------------------
+	// Interactive footer (TUI). Replaces the built-in footer with a line
+	// per spec — "🔄 antiloop(on|off)" — plus live detection info, a
+	// keyboard toggle (esc+a by default, configurable/off), and the
+	// built-in footer's useful data (pwd, branch, ctx %, model) preserved.
+	// ------------------------------------------------------------------
+	function installFooter(ctx: ExtensionContext): void {
+		if (!config.interactiveFooter || ctx.mode !== "tui") {
+			ctx.ui.setFooter(undefined);
+			return;
+		}
+		ctx.ui.setFooter((tui, theme, footerData) => {
+			activeTui = tui;
+
+			// Keyboard toggle from raw terminal input: escape followed by `a`.
+			// We never consume the input, so typing is unaffected — ESC alone
+			// passes through, and an accidental toggle is easily reversed.
+			let pendingEsc = false;
+			const shortcut = config.toggleShortcut;
+			const unsubInput =
+				shortcut === "off"
+					? undefined
+					: ctx.ui.onTerminalInput?.((data: string) => {
+							if (config.toggleShortcut === "off") return undefined;
+							if (data === "\x1b") {
+								pendingEsc = true;
+								return undefined;
+							}
+							if (pendingEsc && data === "a") {
+								pendingEsc = false;
+								toggleEnabled(ctx);
+								return undefined;
+							}
+							pendingEsc = false;
+							return undefined;
+					  });
+
+			return {
+				dispose() {
+					unsubInput?.();
+					if (activeTui === tui) activeTui = undefined;
+				},
+				invalidate() {},
+				render(width: number): string[] {
+					const lines: string[] = [];
+
+					// Line 1: the spec indicator + toggle hint.
+					const status = antiloopStatusText();
+					const colored = config.enabled ? theme.fg("accent", status) : theme.fg("dim", status);
+					const hint =
+						config.toggleShortcut !== "off"
+							? theme.fg("dim", `  [${config.toggleShortcut}] toggle`)
+							: theme.fg("dim", "  [/antiloop] toggle");
+					lines.push(truncateToWidth(colored + hint, width));
+
+					// Line 2 (only while detecting): level + consecutive + last reason.
+					if (state.currentLevel > 0) {
+						const last = state.detections[state.detections.length - 1];
+						const desc = last ? ` · ${last.description}` : "";
+						lines.push(
+							truncateToWidth(
+								theme.fg("warning", `${LEVEL_NAMES[state.currentLevel]} ×${state.consecutiveDetections}${desc}`),
+								width,
+							),
+						);
+					}
+
+					// Line 3: built-in footer data preserved (dim).
+					let info = formatCwd(ctx.cwd);
+					const branch = footerData.getGitBranch();
+					if (branch) info += ` (${branch})`;
+					const usage = ctx.getContextUsage();
+					const cw = usage?.contextWindow ?? ctx.model?.contextWindow;
+					if (cw && usage && usage.percent !== null) info += ` · ctx ${Math.round(usage.percent)}%`;
+					if (ctx.model) info += ` · ${ctx.model.id}`;
+					lines.push(truncateToWidth(theme.fg("dim", info), width));
+
+					// Line 4 (only when other extensions set statuses): keep them visible.
+					const others = Array.from(footerData.getExtensionStatuses().entries())
+						.filter(([k]) => k !== "antiloop")
+						.map(([, v]) => v);
+					if (others.length) {
+						lines.push(truncateToWidth(theme.fg("dim", others.join("  ")), width));
+					}
+
+					return lines;
+				},
+			};
+		});
+	}
+
 	pi.on("message_end", async (event) => {
 		if (!config.enabled) return;
 		const msg = event.message;
@@ -180,9 +307,17 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		Object.assign(config, loadConfig());
 		state = newState();
 		rt.pendingIntervention = null;
+		installFooter(ctx);
 		updateStatus(ctx);
 	});
 
+	pi.on("session_shutdown", async (_e, ctx) => {
+		// Restore the built-in footer on shutdown (in case another extension
+		// installs its own footer later, or the TUI is torn down).
+		ctx.ui.setFooter(undefined);
+		activeTui = undefined;
+	});
+
 	pi.registerCommand("antiloop", {
 		description: "antiloop: detect & break reasoning loops",
 		getArgumentCompletions: (prefix: string) => {
@@ -195,5 +330,3 @@ export default function antiloopExtension(pi: ExtensionAPI) {
 		},
 	});
 }
-
-

package/src/types.ts

@@ -31,6 +31,17 @@ export interface AntiloopConfig {
 	notifyOnDetection: boolean;
 	maxHistoryEntries: number;
 	detectionWindow: number;
+	/**
+	 * Show the antiloop indicator as a custom interactive footer in TUI mode
+	 * (replaces the built-in footer). When false, the indicator is still shown
+	 * as a status line in the built-in footer via ctx.ui.setStatus.
+	 */
+	interactiveFooter: boolean;
+	/**
+	 * Key sequence that toggles antiloop from the footer (raw terminal input).
+	 * Format: "esc+a" (escape followed by `a`) or "off" to disable.
+	 */
+	toggleShortcut: string;
 }
 
 export type LoopKind = "text" | "tool" | "thinking" | "structural";
@@ -81,4 +92,6 @@ export interface Runtime {
 	state: AntiloopState;
 	pendingIntervention: string | null;
 	updateStatus(ctx: ExtensionContext): void;
+	/** Re-install the interactive footer (after config changes). */
+	refreshFooter?(ctx: ExtensionContext): void;
 }