@dungle-scrubs/tallow 0.8.27 → 0.9.0

package/node_modules/@mariozechner/pi-tui/src/keys.ts

@@ -819,7 +819,10 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
 			if (modifier === 0) {
 				return data === "\t" || matchesKittySequence(data, CODEPOINTS.tab, 0);
 			}
-			return matchesKittySequence(data, CODEPOINTS.tab, modifier);
+			return (
+				matchesKittySequence(data, CODEPOINTS.tab, modifier) ||
+				matchesModifyOtherKeys(data, CODEPOINTS.tab, modifier)
+			);
 
 		case "enter":
 		case "return":
@@ -873,7 +876,8 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
 			}
 			return (
 				matchesKittySequence(data, CODEPOINTS.enter, modifier) ||
-				matchesKittySequence(data, CODEPOINTS.kpEnter, modifier)
+				matchesKittySequence(data, CODEPOINTS.kpEnter, modifier) ||
+				matchesModifyOtherKeys(data, CODEPOINTS.enter, modifier)
 			);
 
 		case "backspace":
@@ -1108,21 +1112,33 @@ export function matchesKey(data: string, keyId: KeyId): boolean {
 		if (ctrl && !shift && !alt) {
 			// Legacy: ctrl+key sends the control character
 			if (rawCtrl && data === rawCtrl) return true;
-			return matchesKittySequence(data, codepoint, MODIFIERS.ctrl);
+			return (
+				matchesKittySequence(data, codepoint, MODIFIERS.ctrl) ||
+				matchesModifyOtherKeys(data, codepoint, MODIFIERS.ctrl)
+			);
 		}
 
 		if (ctrl && shift && !alt) {
-			return matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl);
+			return (
+				matchesKittySequence(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl) ||
+				matchesModifyOtherKeys(data, codepoint, MODIFIERS.shift + MODIFIERS.ctrl)
+			);
 		}
 
 		if (shift && !ctrl && !alt) {
 			// Legacy: shift+letter produces uppercase
 			if (data === key.toUpperCase()) return true;
-			return matchesKittySequence(data, codepoint, MODIFIERS.shift);
+			return (
+				matchesKittySequence(data, codepoint, MODIFIERS.shift) ||
+				matchesModifyOtherKeys(data, codepoint, MODIFIERS.shift)
+			);
 		}
 
 		if (modifier !== 0) {
-			return matchesKittySequence(data, codepoint, modifier);
+			return (
+				matchesKittySequence(data, codepoint, modifier) ||
+				matchesModifyOtherKeys(data, codepoint, modifier)
+			);
 		}
 
 		// Check both raw char and Kitty sequence (needed for release events)
@@ -1251,3 +1267,65 @@ export function parseKey(data: string): string | undefined {
 
 	return undefined;
 }
+
+// =============================================================================
+// Mouse Event Parsing
+// =============================================================================
+
+/**
+ * Parsed mouse event from SGR extended format.
+ * SGR format: \x1b[<button;column;row[Mm]
+ * M = press, m = release
+ */
+export interface MouseEvent {
+	/** Event type */
+	type: "scroll-up" | "scroll-down" | "press" | "release" | "drag";
+	/** 0=left, 1=middle, 2=right */
+	button: number;
+	/** 1-indexed column */
+	x: number;
+	/** 1-indexed row */
+	y: number;
+}
+
+/** SGR extended mouse format: \x1b[<button;x;y[Mm] */
+const SGR_MOUSE_RE = /^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/;
+
+/**
+ * Parse an SGR mouse event from raw terminal input.
+ *
+ * @param data - Raw terminal input
+ * @returns Parsed mouse event, or null if not a mouse sequence
+ */
+export function parseMouseEvent(data: string): MouseEvent | null {
+	const match = data.match(SGR_MOUSE_RE);
+	if (!match) return null;
+
+	const code = parseInt(match[1]!, 10);
+	const x = parseInt(match[2]!, 10);
+	const y = parseInt(match[3]!, 10);
+	const isRelease = match[4] === "m";
+
+	// Scroll wheel: codes 64 (up) and 65 (down)
+	if (code === 64) return { type: "scroll-up", button: 0, x, y };
+	if (code === 65) return { type: "scroll-down", button: 0, x, y };
+
+	// Button number is in the low 2 bits
+	const button = code & 0x03;
+
+	// Bit 5 (32) = motion/drag
+	if (code & 32) return { type: "drag", button, x, y };
+
+	return { type: isRelease ? "release" : "press", button, x, y };
+}
+
+/**
+ * Fast check: is this data an SGR mouse event?
+ * Avoids regex for non-mouse input.
+ *
+ * @param data - Raw terminal input
+ * @returns true if the input is an SGR mouse sequence
+ */
+export function isMouseEvent(data: string): boolean {
+	return data.length >= 9 && data.startsWith("\x1b[<");
+}

package/node_modules/@mariozechner/pi-tui/src/terminal.ts

@@ -30,6 +30,9 @@ export interface Terminal {
 	// Whether Kitty keyboard protocol is active
 	get kittyProtocolActive(): boolean;
 
+	// Whether running inside tmux (using modifyOtherKeys instead of Kitty protocol)
+	get isTmux(): boolean;
+
 	// Cursor positioning (relative to current position)
 	moveBy(lines: number): void; // Move cursor up (negative) or down (positive) by N lines
 
@@ -42,6 +45,10 @@ export interface Terminal {
 	clearFromCursor(): void; // Clear from cursor to end of screen
 	clearScreen(): void; // Clear entire screen and move cursor to (0,0)
 
+	// Mouse reporting
+	enableMouse(): void; // Enable SGR mouse tracking (scroll, click)
+	disableMouse(): void; // Disable mouse tracking
+
 	// Screen buffer mode
 	enterAlternateScreen(): void; // Switch to alternate screen buffer (no scrollback)
 	leaveAlternateScreen(): void; // Restore normal screen buffer and scrollback
@@ -67,11 +74,16 @@ export class ProcessTerminal implements Terminal {
 	private stdinDataHandler?: (data: string) => void;
 	private writeLogPath = process.env.PI_TUI_WRITE_LOG || "";
 	private alternateScreenActive = false;
+	private mouseActive = false;
 
 	get kittyProtocolActive(): boolean {
 		return this._kittyProtocolActive;
 	}
 
+	get isTmux(): boolean {
+		return !!process.env.TMUX;
+	}
+
 	start(onInput: (data: string) => void, onResize: () => void): void {
 		this.inputHandler = onInput;
 		this.resizeHandler = onResize;
@@ -97,10 +109,24 @@ export class ProcessTerminal implements Terminal {
 			process.kill(process.pid, "SIGWINCH");
 		}
 
-		// Query and enable Kitty keyboard protocol
-		// The query handler intercepts input temporarily, then installs the user's handler
-		// See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
-		this.queryAndEnableKittyProtocol();
+		// Mouse tracking (enableMouse/disableMouse) is available but NOT
+		// enabled anywhere yet. The TUI has no scroll viewport — content
+		// off-screen is only reachable via terminal scrollback (or tmux
+		// copy-mode). Enabling mouse tracking steals scroll events without
+		// providing scroll handling, making things strictly worse. Enable
+		// only after implementing a scroll viewport in the TUI.
+
+		// Enable keyboard protocol for modified key detection.
+		// tmux doesn't support the Kitty keyboard protocol but does support xterm's
+		// modifyOtherKeys. Detect tmux and use the appropriate protocol.
+		if (process.env.TMUX) {
+			this.setupTmuxInput();
+		} else {
+			// Query and enable Kitty keyboard protocol
+			// The query handler intercepts input temporarily, then installs the user's handler
+			// See: https://sw.kovidgoyal.net/kitty/keyboard-protocol/
+			this.queryAndEnableKittyProtocol();
+		}
 	}
 
 	/**
@@ -154,6 +180,22 @@ export class ProcessTerminal implements Terminal {
 		};
 	}
 
+	/**
+	 * Set up stdin handling for tmux without Kitty keyboard protocol.
+	 *
+	 * tmux doesn't support the Kitty keyboard protocol. Escape and Ctrl+C
+	 * arrive as raw bytes (\x1b and \x03) which the key matching handles natively.
+	 *
+	 * For Shift+Enter, tmux needs `extended-keys on` and `extended-keys-format csi-u`
+	 * in tmux.conf. With that config, we request modifyOtherKeys mode 1 so tmux
+	 * encodes modified keys (Shift+Enter → CSI 13;2 u) while leaving standard
+	 * keys (Escape, Ctrl+C, regular typing) as raw bytes.
+	 */
+	private setupTmuxInput(): void {
+		this.setupStdinBuffer();
+		process.stdin.on("data", this.stdinDataHandler!);
+	}
+
 	/**
 	 * Query terminal for Kitty keyboard protocol support and enable if available.
 	 *
@@ -209,6 +251,9 @@ export class ProcessTerminal implements Terminal {
 			this.leaveAlternateScreen();
 		}
 
+		// Disable mouse tracking
+		this.disableMouse();
+
 		// Disable bracketed paste mode
 		process.stdout.write("\x1b[?2004l");
 
@@ -297,6 +342,26 @@ export class ProcessTerminal implements Terminal {
 		process.stdout.write("\x1b[2J\x1b[H"); // Clear screen and move to home (1,1)
 	}
 
+	/**
+	 * Enable SGR mouse tracking.
+	 * Mode 1000 = button press/release (includes scroll wheel).
+	 * Mode 1006 = SGR extended format (avoids 223-column limit).
+	 */
+	enableMouse(): void {
+		if (this.mouseActive) return;
+		process.stdout.write("\x1b[?1000h\x1b[?1006h");
+		this.mouseActive = true;
+	}
+
+	/**
+	 * Disable mouse tracking and restore default terminal mouse handling.
+	 */
+	disableMouse(): void {
+		if (!this.mouseActive) return;
+		process.stdout.write("\x1b[?1006l\x1b[?1000l");
+		this.mouseActive = false;
+	}
+
 	/**
 	 * Switch to alternate screen buffer and clear it.
 	 * @returns void

package/node_modules/@mariozechner/pi-tui/src/tui.ts

@@ -5,7 +5,13 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { isKeyRelease, matchesKey } from "./keys.js";
+import {
+	isKeyRelease,
+	isMouseEvent,
+	type MouseEvent,
+	matchesKey,
+	parseMouseEvent,
+} from "./keys.js";
 import type { Terminal } from "./terminal.js";
 import { getCapabilities, isImageLine, setCellDimensions } from "./terminal-image.js";
 import {
@@ -209,6 +215,13 @@ export class TUI extends Container {
 
 	/** Global callback for debug key (Shift+Ctrl+D). Called before input is forwarded to focused component. */
 	public onDebug?: () => void;
+	/**
+	 * Callback for mouse events. Called when a mouse event is received.
+	 * Scroll events are the primary use case (scroll-up, scroll-down).
+	 * Return value is ignored — mouse events are always consumed and never
+	 * forwarded to focused components.
+	 */
+	public onMouse?: (event: MouseEvent) => void;
 	private renderRequested = false;
 	private pendingRenderHandle?: ReturnType<typeof setTimeout>;
 	private cursorRow = 0; // Logical cursor row (end of rendered content)
@@ -220,6 +233,7 @@ export class TUI extends Container {
 	private maxLinesRendered = 0; // Track terminal's working area (max lines ever rendered)
 	private previousViewportTop = 0; // Track previous viewport top for resize-aware cursor moves
 	private fullRedrawCount = 0;
+	private rollingShrinkPeak = 0; // Recent peak line count for gradual shrink detection
 	private stopped = false;
 	private pendingScrollbackClear = false; // Clear scrollback on next full render (session breaks)
 
@@ -269,6 +283,19 @@ export class TUI extends Container {
 		this.clearOnShrink = enabled;
 	}
 
+	/**
+	 * Reset the startup grace period timer, suppressing screen-clearing full
+	 * redraws for another {@link STARTUP_GRACE_MS} milliseconds.
+	 *
+	 * Call this at the start of a session switch so the chatContainer.clear()
+	 * → renderInitialMessages() transition doesn't cause visible flicker.
+	 *
+	 * @returns {void}
+	 */
+	resetRenderGrace(): void {
+		this.startedAtMs = Date.now();
+	}
+
 	/**
 	 * Request that the next full render clears the terminal scrollback buffer.
 	 *
@@ -389,8 +416,25 @@ export class TUI extends Container {
 		for (const overlay of this.overlayStack) overlay.component.invalidate?.();
 	}
 
+	/**
+	 * Timestamp when `start()` was called.
+	 * Used by startup grace period to suppress screen-clearing full redraws.
+	 */
+	private startedAtMs = 0;
+
+	/**
+	 * Duration (ms) after `start()` during which shrink-triggered full redraws
+	 * use a gentler line-by-line overwrite instead of screen clear.
+	 *
+	 * This prevents the visual flicker that occurs when session resume causes
+	 * rapid content height changes (extension hooks, widget adds/removes) before
+	 * the full message history is rendered.
+	 */
+	private static readonly STARTUP_GRACE_MS = 3000;
+
 	start(): void {
 		this.stopped = false;
+		this.startedAtMs = Date.now();
 		this.terminal.start(
 			(data) => this.handleInput(data),
 			() => this.requestRender()
@@ -405,6 +449,12 @@ export class TUI extends Container {
 		if (!getCapabilities().images) {
 			return;
 		}
+		// Skip cell size query inside tmux — tmux doesn't forward CSI 16 t responses,
+		// so cellSizeQueryPending would stay true and parseCellSizeResponse would eat
+		// bare \x1b (Escape key) as a "partial response", breaking Escape handling.
+		if (process.env.TMUX) {
+			return;
+		}
 		// Query terminal for cell size in pixels: CSI 16 t
 		// Response format: CSI 6 ; height ; width t
 		this.cellSizeQueryPending = true;
@@ -434,6 +484,45 @@ export class TUI extends Container {
 		this.terminal.stop();
 	}
 
+	/** When >0, scheduled renders are deferred until the batch completes. */
+	private renderBatchDepth = 0;
+
+	/** Whether a render was requested while batching was active. */
+	private renderDeferredDuringBatch = false;
+
+	/** Whether a forced render was requested while batching was active. */
+	private renderForceDeferredDuringBatch = false;
+
+	/**
+	 * Begin a render batch — all `requestRender()` calls are coalesced and
+	 * deferred until the matching `endRenderBatch()`. Nestable.
+	 *
+	 * Use to prevent intermediate renders (and the screen clears they cause)
+	 * during multi-step UI mutations such as session resume.
+	 *
+	 * @returns {void}
+	 */
+	beginRenderBatch(): void {
+		this.renderBatchDepth++;
+	}
+
+	/**
+	 * End a render batch. When the outermost batch ends, a single render is
+	 * scheduled if any were deferred.
+	 *
+	 * @returns {void}
+	 */
+	endRenderBatch(): void {
+		if (this.renderBatchDepth <= 0) return;
+		this.renderBatchDepth--;
+		if (this.renderBatchDepth === 0 && this.renderDeferredDuringBatch) {
+			const wasForce = this.renderForceDeferredDuringBatch;
+			this.renderDeferredDuringBatch = false;
+			this.renderForceDeferredDuringBatch = false;
+			this.requestRender(wasForce);
+		}
+	}
+
 	requestRender(force = false): void {
 		if (force) {
 			this.previousLines = [];
@@ -442,6 +531,12 @@ export class TUI extends Container {
 			this.hardwareCursorRow = 0;
 			this.maxLinesRendered = 0;
 			this.previousViewportTop = 0;
+			this.rollingShrinkPeak = 0;
+		}
+		if (this.renderBatchDepth > 0) {
+			this.renderDeferredDuringBatch = true;
+			if (force) this.renderForceDeferredDuringBatch = true;
+			return;
 		}
 		if (this.renderRequested) return;
 		this.scheduleRender();
@@ -511,6 +606,16 @@ export class TUI extends Container {
 			data = filtered;
 		}
 
+		// Mouse events — intercept before any key handling.
+		// Always consumed: mouse sequences must never reach components as text.
+		if (isMouseEvent(data)) {
+			const event = parseMouseEvent(data);
+			if (event && this.onMouse) {
+				this.onMouse(event);
+			}
+			return;
+		}
+
 		// Global debug key handler (Shift+Ctrl+D)
 		if (matchesKey(data, "shift+ctrl+d") && this.onDebug) {
 			this.onDebug();
@@ -556,6 +661,19 @@ export class TUI extends Container {
 			if (isKeyRelease(data) && !this.focusedComponent.wantsKeyRelease) {
 				return;
 			}
+			if (process.env.TALLOW_KEY_DEBUG && (data === "\x1b" || data === "\x03")) {
+				const escMatch = matchesKey(data, "escape");
+				const ctrlcMatch = matchesKey(data, "ctrl+c");
+				const comp = this.focusedComponent as unknown as {
+					onEscape?: () => void;
+					actionHandlers?: Map<string, unknown>;
+				};
+				const hasOnEscape = typeof comp.onEscape === "function";
+				const actionCount = comp.actionHandlers instanceof Map ? comp.actionHandlers.size : -1;
+				process.stderr.write(
+					`[key] ${data === "\x1b" ? "ESC" : "C-C"} matchEsc=${escMatch} matchCC=${ctrlcMatch} hasOnEscape=${hasOnEscape} actions=${actionCount}\n`
+				);
+			}
 			this.focusedComponent.handleInput(data);
 			this.requestRender();
 		}
@@ -960,6 +1078,11 @@ export class TUI extends Container {
 		// Width changed - need full re-render (line wrapping changes)
 		const widthChanged = this.previousWidth !== 0 && this.previousWidth !== width;
 
+		// Whether we are within the startup grace period where screen-clearing
+		// full redraws are softened to prevent flicker during session resume.
+		const inStartupGrace =
+			this.startedAtMs > 0 && Date.now() - this.startedAtMs < TUI.STARTUP_GRACE_MS;
+
 		// Helper to clear viewport (and optionally scrollback) and render all new lines
 		const fullRender = (clear: boolean): void => {
 			this.fullRedrawCount += 1;
@@ -985,6 +1108,45 @@ export class TUI extends Container {
 				this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
 			}
 			this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
+			this.rollingShrinkPeak = newLines.length;
+			this.positionHardwareCursor(cursorPos, newLines.length);
+			this.previousLines = newLines;
+			this.previousWidth = width;
+		};
+
+		/**
+		 * Gentle full redraw: home cursor + overwrite each line + clear below.
+		 *
+		 * Used during the startup grace period instead of fullRender(true) for
+		 * shrink-triggered redraws. Avoids the visible blank frame caused by
+		 * `\x1b[2J` (clear screen), which makes messages appear to flash in and
+		 * out when session resume triggers rapid content height changes.
+		 *
+		 * Unlike fullRender(true), this never clears the screen — it writes each
+		 * line with a preceding `\x1b[2K` (clear line) so stale content is
+		 * overwritten without a blank frame. Lines below the new content are
+		 * individually erased.
+		 */
+		const gentleFullRender = (): void => {
+			this.fullRedrawCount += 1;
+			let buffer = "\x1b[?2026h\x1b[H"; // Begin synchronized output + home cursor
+			for (let i = 0; i < newLines.length; i++) {
+				buffer += "\x1b[2K"; // Clear current line
+				buffer += newLines[i];
+				if (i < newLines.length - 1) buffer += "\r\n";
+			}
+			// Erase lines that were previously rendered but are no longer needed
+			const staleLines = Math.max(0, this.maxLinesRendered - newLines.length);
+			for (let i = 0; i < staleLines; i++) {
+				buffer += "\r\n\x1b[2K";
+			}
+			buffer += "\x1b[?2026l"; // End synchronized output
+			this.terminal.write(buffer);
+			this.cursorRow = Math.max(0, newLines.length + staleLines - 1);
+			this.hardwareCursorRow = this.cursorRow;
+			this.maxLinesRendered = newLines.length;
+			this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
+			this.rollingShrinkPeak = newLines.length;
 			this.positionHardwareCursor(cursorPos, newLines.length);
 			this.previousLines = newLines;
 			this.previousWidth = width;
@@ -1021,7 +1183,11 @@ export class TUI extends Container {
 			this.overlayStack.length === 0
 		) {
 			logRedraw(`clearOnShrink (maxLinesRendered=${this.maxLinesRendered})`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1032,7 +1198,30 @@ export class TUI extends Container {
 		const shrinkDelta = this.previousLines.length - newLines.length;
 		if (shrinkDelta > 5 && this.overlayStack.length === 0) {
 			logRedraw(`large shrink (${shrinkDelta} lines)`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
+			return;
+		}
+
+		// Rolling shrink detection: catches gradual shrinks where each individual
+		// frame-to-frame delta is ≤5 lines (below the large-shrink threshold) but the
+		// accumulated shrink from a recent peak exceeds it. This happens when
+		// pollStates.clear() collapses tool-result anchors across multiple render
+		// cycles while animations (loader, widget spinners) keep triggering renders.
+		if (newLines.length >= this.rollingShrinkPeak) {
+			this.rollingShrinkPeak = newLines.length;
+		} else if (this.overlayStack.length === 0 && this.rollingShrinkPeak - newLines.length > 5) {
+			logRedraw(
+				`rolling shrink (peak=${this.rollingShrinkPeak}, now=${newLines.length}, delta=${this.rollingShrinkPeak - newLines.length})`
+			);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1107,7 +1296,11 @@ export class TUI extends Container {
 				const extraLines = this.previousLines.length - newLines.length;
 				if (extraLines > height) {
 					logRedraw(`extraLines > height (${extraLines} > ${height})`);
-					fullRender(true);
+					if (inStartupGrace) {
+						gentleFullRender();
+					} else {
+						fullRender(true);
+					}
 					return;
 				}
 				if (extraLines > 0) {
@@ -1135,7 +1328,11 @@ export class TUI extends Container {
 		// If first changed line is above the current viewport basis, partial redraw is unsafe.
 		if (firstChanged < prevViewportTop) {
 			logRedraw(`firstChanged < viewportTop (${firstChanged} < ${prevViewportTop})`);
-			fullRender(true);
+			if (inStartupGrace) {
+				gentleFullRender();
+			} else {
+				fullRender(true);
+			}
 			return;
 		}
 
@@ -1306,6 +1503,9 @@ export class TUI extends Container {
 			this.maxLinesRendered = Math.max(this.maxLinesRendered, newLines.length);
 		}
 		this.previousViewportTop = Math.max(0, this.maxLinesRendered - height);
+		// Update rolling peak for gradual shrink detection (partial path only —
+		// fullRender paths reset it inside the fullRender closure).
+		this.rollingShrinkPeak = Math.max(this.rollingShrinkPeak, newLines.length);
 
 		// Position hardware cursor for IME
 		this.positionHardwareCursor(cursorPos, newLines.length);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@dungle-scrubs/tallow",
-	"version": "0.8.27",
+	"version": "0.9.0",
 	"description": "An opinionated coding agent. Built on pi.",
 	"piConfig": {
 		"name": "tallow",
@@ -74,25 +74,25 @@
 	},
 	"dependencies": {
 		"@clack/prompts": "^1.1.0",
-		"@dungle-scrubs/synapse": "0.1.6",
-		"@mariozechner/pi-coding-agent": "^0.60.0",
-		"@mariozechner/pi-tui": "^0.60.0",
+		"@dungle-scrubs/synapse": "0.1.8",
+		"@mariozechner/pi-coding-agent": "^0.64.0",
+		"@mariozechner/pi-tui": "^0.62.0",
 		"@opentelemetry/api": "^1.9.0",
 		"@sinclair/typebox": "0.34.48",
 		"ai": "^6.0.116",
 		"commander": "^14.0.3",
 		"unpdf": "^1.4.0",
-		"vscode-jsonrpc": "8.2.1"
+		"vscode-jsonrpc": "8.2.1",
+		"vscode-languageserver-protocol": "3.17.5"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.2",
-		"@mariozechner/pi-agent-core": "^0.60.0",
-		"@mariozechner/pi-ai": "^0.60.0",
+		"@mariozechner/pi-agent-core": "^0.64.0",
+		"@mariozechner/pi-ai": "^0.64.0",
 		"@types/node": "25.2.3",
 		"husky": "^9.1.7",
 		"lint-staged": "^16.4.0",
-		"typescript": "^5.9.3",
-		"vscode-languageserver-protocol": "3.17.5"
+		"typescript": "^5.9.3"
 	},
 	"engines": {
 		"node": ">=22"

package/runtime/config.ts

@@ -0,0 +1,7 @@
+import { resolveRuntimeModuleUrl } from "./resolve-module.js";
+
+const mod = (await import(
+	resolveRuntimeModuleUrl("config.js")
+)) as typeof import("../src/config.js");
+
+export const TALLOW_VERSION = mod.TALLOW_VERSION;

package/runtime/model-metadata-overrides.ts

@@ -0,0 +1,7 @@
+import { resolveRuntimeModuleUrl } from "./resolve-module.js";
+
+const mod = (await import(
+	resolveRuntimeModuleUrl("model-metadata-overrides.js")
+)) as typeof import("../src/model-metadata-overrides.js");
+
+export const applyKnownModelMetadataOverrides = mod.applyKnownModelMetadataOverrides;

package/schemas/settings.schema.json

@@ -429,11 +429,6 @@
 					"default": ["◐", "◓", "◑", "◒"],
 					"minItems": 1
 				},
-				"plan_mode": {
-					"type": "string",
-					"description": "Plan mode indicator (default: '⏸').",
-					"default": "⏸"
-				},
 				"task_list": {
 					"type": "string",
 					"description": "Task list indicator (default: '📋').",