@oh-my-pi/pi-coding-agent 6.8.0 → 6.8.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [6.8.1] - 2026-01-20
+
+### Fixed
+
+- Fixed unhandled promise rejection when tool execution fails by adding missing `.catch()` to floating `.finally()` chain in `createAbortablePromise`
+
 ## [6.8.0] - 2026-01-20
 
 ### Added

package/examples/extensions/plan-mode.ts

@@ -247,16 +247,16 @@ export default function planModeExtension(pi: ExtensionAPI) {
 		}
 	}
 
-	function togglePlanMode(ctx: ExtensionContext) {
+	async function togglePlanMode(ctx: ExtensionContext) {
 		planModeEnabled = !planModeEnabled;
 		executionMode = false;
 		todoItems = [];
 
 		if (planModeEnabled) {
-			pi.setActiveTools(PLAN_MODE_TOOLS);
+			await pi.setActiveTools(PLAN_MODE_TOOLS);
 			ctx.ui.notify(`Plan mode enabled. Tools: ${PLAN_MODE_TOOLS.join(", ")}`);
 		} else {
-			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			await pi.setActiveTools(NORMAL_MODE_TOOLS);
 			ctx.ui.notify("Plan mode disabled. Full access restored.");
 		}
 		updateStatus(ctx);
@@ -266,7 +266,7 @@ export default function planModeExtension(pi: ExtensionAPI) {
 	pi.registerCommand("plan", {
 		description: "Toggle plan mode (read-only exploration)",
 		handler: async (_args, ctx) => {
-			togglePlanMode(ctx);
+			await togglePlanMode(ctx);
 		},
 	});
 
@@ -294,7 +294,7 @@ export default function planModeExtension(pi: ExtensionAPI) {
 	pi.registerShortcut(Key.shift("p"), {
 		description: "Toggle plan mode",
 		handler: async (ctx) => {
-			togglePlanMode(ctx);
+			await togglePlanMode(ctx);
 		},
 	});
 
@@ -417,7 +417,7 @@ Execute each step in order.`,
 
 				executionMode = false;
 				todoItems = [];
-				pi.setActiveTools(NORMAL_MODE_TOOLS);
+				await pi.setActiveTools(NORMAL_MODE_TOOLS);
 				updateStatus(ctx);
 			}
 			return;
@@ -470,7 +470,7 @@ Execute each step in order.`,
 		if (choice?.startsWith("Execute")) {
 			planModeEnabled = false;
 			executionMode = hasTodos;
-			pi.setActiveTools(NORMAL_MODE_TOOLS);
+			await pi.setActiveTools(NORMAL_MODE_TOOLS);
 			updateStatus(ctx);
 
 			// Simple execution message - context event filters old plan mode messages
@@ -519,7 +519,7 @@ Execute each step in order.`,
 		}
 
 		if (planModeEnabled) {
-			pi.setActiveTools(PLAN_MODE_TOOLS);
+			await pi.setActiveTools(PLAN_MODE_TOOLS);
 		}
 		updateStatus(ctx);
 	});

package/examples/extensions/tools.ts

@@ -31,12 +31,12 @@ export default function toolsExtension(pi: ExtensionAPI) {
 	}
 
 	// Apply current tool selection
-	function applyTools() {
-		pi.setActiveTools(Array.from(enabledTools));
+	async function applyTools() {
+		await pi.setActiveTools(Array.from(enabledTools));
 	}
 
 	// Find the last tools-config entry in the current branch
-	function restoreFromBranch(ctx: ExtensionContext) {
+	async function restoreFromBranch(ctx: ExtensionContext) {
 		allTools = pi.getAllTools();
 
 		// Get entries in current branch only
@@ -55,7 +55,7 @@ export default function toolsExtension(pi: ExtensionAPI) {
 		if (savedTools) {
 			// Restore saved tool selection (filter to only tools that still exist)
 			enabledTools = new Set(savedTools.filter((t: string) => allTools.includes(t)));
-			applyTools();
+			await applyTools();
 		} else {
 			// No saved state - sync with currently active tools
 			enabledTools = new Set(pi.getActiveTools());
@@ -130,16 +130,16 @@ export default function toolsExtension(pi: ExtensionAPI) {
 
 	// Restore state on session start
 	pi.on("session_start", async (_event, ctx) => {
-		restoreFromBranch(ctx);
+		await restoreFromBranch(ctx);
 	});
 
 	// Restore state when navigating the session tree
 	pi.on("session_tree", async (_event, ctx) => {
-		restoreFromBranch(ctx);
+		await restoreFromBranch(ctx);
 	});
 
 	// Restore state after branching
 	pi.on("session_branch", async (_event, ctx) => {
-		restoreFromBranch(ctx);
+		await restoreFromBranch(ctx);
 	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.8.0",
+	"version": "6.8.1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,11 +40,11 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.8.0",
-		"@oh-my-pi/pi-ai": "6.8.0",
-		"@oh-my-pi/pi-git-tool": "6.8.0",
-		"@oh-my-pi/pi-tui": "6.8.0",
-		"@oh-my-pi/pi-utils": "6.8.0",
+		"@oh-my-pi/pi-agent-core": "6.8.1",
+		"@oh-my-pi/pi-ai": "6.8.1",
+		"@oh-my-pi/pi-git-tool": "6.8.1",
+		"@oh-my-pi/pi-tui": "6.8.1",
+		"@oh-my-pi/pi-utils": "6.8.1",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/cli/session-picker.ts

@@ -28,8 +28,11 @@ export async function selectSession(sessions: SessionInfo[]): Promise<string | n
 			}
 		},
 		() => {
-			ui.stop();
-			process.exit(0);
+			if (!resolved) {
+				resolved = true;
+				ui.stop();
+				process.exit(0);
+			}
 		},
 	);
 

package/src/core/agent-session.ts

@@ -2226,7 +2226,7 @@ export class AgentSession {
 								error: message,
 								model: `${candidate.provider}/${candidate.id}`,
 							});
-							await Bun.sleep(delayMs);
+							await abortableSleep(delayMs, this._autoCompactionAbortController.signal);
 						}
 					}
 
@@ -2291,6 +2291,10 @@ export class AgentSession {
 				}, 100);
 			}
 		} catch (error) {
+			if (this._autoCompactionAbortController?.signal.aborted) {
+				this._emit({ type: "auto_compaction_end", result: undefined, aborted: true, willRetry: false });
+				return;
+			}
 			const errorMessage = error instanceof Error ? error.message : "compaction failed";
 			this._emit({
 				type: "auto_compaction_end",

package/src/core/auth-storage.ts

@@ -107,10 +107,12 @@ function toBoolean(value: unknown): boolean | undefined {
 export class AuthStorage {
 	private static readonly codexUsageCacheTtlMs = 60_000; // Cache usage data for 1 minute
 	private static readonly defaultBackoffMs = 60_000; // Default backoff when no reset time available
+	private static readonly cacheCleanupIntervalMs = 300_000; // Clean expired cache every 5 minutes
 
 	/** Provider -> credentials cache, populated from agent.db on reload(). */
 	private data: Map<string, StoredCredential[]> = new Map();
 	private storage: AgentStorage;
+	private lastCacheCleanup = 0;
 	/** Resolved path to agent.db (derived from authPath or used directly if .db). */
 	private dbPath: string;
 	private runtimeOverrides: Map<string, string> = new Map();
@@ -153,6 +155,7 @@ export class AuthStorage {
 		instance.sessionLastCredential = new Map();
 		instance.credentialBackoff = new Map();
 		instance.codexUsageCache = new Map();
+		instance.lastCacheCleanup = 0;
 
 		for (const [provider, creds] of Object.entries(data.credentials)) {
 			instance.data.set(
@@ -748,6 +751,11 @@ export class AuthStorage {
 		const cacheKey = this.getCodexUsageCacheKey(accountId, normalizedBase);
 		const now = Date.now();
 
+		if (now - this.lastCacheCleanup > AuthStorage.cacheCleanupIntervalMs) {
+			this.lastCacheCleanup = now;
+			this.storage.cleanExpiredCache();
+		}
+
 		// Check in-memory cache first (fastest)
 		const memCached = this.codexUsageCache.get(cacheKey);
 		if (memCached && memCached.expiresAt > now) {

package/src/core/bash-executor.ts

@@ -4,7 +4,7 @@
  * Provides unified bash execution for AgentSession.executeBash() and direct calls.
  */
 
-import { cspawn, Exception } from "@oh-my-pi/pi-utils";
+import { cspawn, Exception, ptree } from "@oh-my-pi/pi-utils";
 import { getShellConfig } from "../utils/shell";
 import { getOrCreateSnapshot, getSnapshotSourceCommand } from "../utils/shell-snapshot";
 import { OutputSink } from "./streaming-output";
@@ -63,7 +63,7 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 		// Exception covers NonZeroExitError, AbortError, TimeoutError
 		if (err instanceof Exception) {
 			if (err.aborted) {
-				const isTimeout = err.message.includes("timed out");
+				const isTimeout = err instanceof ptree.TimeoutError || err.message.toLowerCase().includes("timed out");
 				const annotation = isTimeout
 					? `Command timed out after ${Math.round((options?.timeout ?? 0) / 1000)} seconds`
 					: undefined;

package/src/core/exec.ts

@@ -41,14 +41,16 @@ export async function execCommand(
 		signal: options?.signal,
 		timeout: options?.timeout,
 	});
+	// Read streams before awaiting exit to avoid data loss if streams close
+	const [stdoutText, stderrText] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
 	try {
 		await proc.exited;
 	} catch {
 		// ChildProcess rejects on non-zero exit; we handle it below
 	}
 	return {
-		stdout: await proc.stdout.text(),
-		stderr: await proc.stderr.text(),
+		stdout: stdoutText,
+		stderr: stderrText,
 		code: proc.exitCode ?? 0,
 		killed: proc.exitReason instanceof ptree.AbortError,
 	};

package/src/core/extensions/types.ts

@@ -757,7 +757,7 @@ export interface ExtensionAPI {
 	getAllTools(): string[];
 
 	/** Set the active tools by name. */
-	setActiveTools(toolNames: string[]): void;
+	setActiveTools(toolNames: string[]): Promise<void>;
 
 	/** Set the current model. Returns false if no API key available. */
 	setModel(model: Model<any>): Promise<boolean>;

package/src/core/hooks/types.ts

@@ -685,12 +685,13 @@ export interface HookAPI {
 	 * @param message.content - Message content (string or TextContent/ImageContent array)
 	 * @param message.display - Whether to show in TUI (true = styled display, false = hidden)
 	 * @param message.details - Optional hook-specific metadata (not sent to LLM)
-	 * @param triggerTurn - If true and agent is idle, triggers a new LLM turn. Default: false.
-	 *                      If agent is streaming, message is queued and triggerTurn is ignored.
+	 * @param options.triggerTurn - If true and agent is idle, triggers a new LLM turn. Default: false.
+	 *                              If agent is streaming, message is queued and triggerTurn is ignored.
+	 * @param options.deliverAs - How to deliver the message: "steer" or "followUp".
 	 */
 	sendMessage<T = unknown>(
 		message: Pick<HookMessage<T>, "customType" | "content" | "display" | "details">,
-		triggerTurn?: boolean,
+		options?: { triggerTurn?: boolean; deliverAs?: "steer" | "followUp" },
 	): void;
 
 	/**

package/src/core/mcp/transports/http.ts

@@ -5,7 +5,7 @@
  * Based on MCP spec 2025-03-26.
  */
 
-import type { JsonRpcResponse, MCPHttpServerConfig, MCPSseServerConfig, MCPTransport } from "../types";
+import type { JsonRpcMessage, JsonRpcResponse, MCPHttpServerConfig, MCPSseServerConfig, MCPTransport } from "../types";
 
 /** Generate unique request ID */
 function generateId(): string {
@@ -167,39 +167,47 @@ export class HttpTransport implements MCPTransport {
 			throw new Error("No response body");
 		}
 
-		let result: T | undefined;
+		const timeout = this.config.timeout ?? 30000;
 
-		for await (const event of readSseEvents(response.body)) {
-			const data = event.data?.trim();
-			if (!data || data === "[DONE]") continue;
-			try {
-				const message = JSON.parse(data) as JsonRpcResponse;
+		const parse = async (): Promise<T> => {
+			for await (const event of readSseEvents(response.body!)) {
+				const data = event.data?.trim();
+				if (!data || data === "[DONE]") continue;
 
-				// Handle our response
-				if ("id" in message && message.id === expectedId) {
-					if (message.error) {
-						throw new Error(`MCP error ${message.error.code}: ${message.error.message}`);
+				try {
+					const message = JSON.parse(data) as JsonRpcMessage;
+
+					if (
+						"id" in message &&
+						(message as JsonRpcResponse).id === expectedId &&
+						("result" in message || "error" in message)
+					) {
+						const response = message as JsonRpcResponse;
+						if (response.error) {
+							throw new Error(`MCP error ${response.error.code}: ${response.error.message}`);
+						}
+						return response.result as T;
+					}
+
+					if ("method" in message && !("id" in message)) {
+						this.onNotification?.(message.method, message.params);
+					}
+				} catch (error) {
+					if (error instanceof Error && error.message.startsWith("MCP error")) {
+						throw error;
 					}
-					result = message.result as T;
-				}
-				// Handle notifications
-				else if ("method" in message && !("id" in message)) {
-					const notification = message as { method: string; params?: unknown };
-					this.onNotification?.(notification.method, notification.params);
-				}
-			} catch (error) {
-				if (error instanceof Error && error.message.startsWith("MCP error")) {
-					throw error;
 				}
-				// Ignore other parse errors
 			}
-		}
 
-		if (result === undefined) {
-			throw new Error("No response received");
-		}
+			throw new Error(`No response received for request ID ${expectedId}`);
+		};
 
-		return result;
+		return Promise.race([
+			parse(),
+			new Promise<never>((_, reject) =>
+				setTimeout(() => reject(new Error(`SSE response timeout after ${timeout}ms`)), timeout),
+			),
+		]);
 	}
 
 	async notify(method: string, params?: Record<string, unknown>): Promise<void> {

package/src/core/python-gateway-coordinator.ts

@@ -116,8 +116,8 @@ const DEFAULT_ENV_DENYLIST = new Set([
 const CASE_INSENSITIVE_ENV = process.platform === "win32";
 const ACTIVE_ENV_ALLOWLIST = CASE_INSENSITIVE_ENV ? WINDOWS_ENV_ALLOWLIST : DEFAULT_ENV_ALLOWLIST;
 
-const NORMALIZED_ALLOWLIST = new Set(
-	Array.from(ACTIVE_ENV_ALLOWLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
+const NORMALIZED_ALLOWLIST = new Map(
+	Array.from(ACTIVE_ENV_ALLOWLIST, (key) => [CASE_INSENSITIVE_ENV ? key.toUpperCase() : key, key] as const),
 );
 const NORMALIZED_DENYLIST = new Set(
 	Array.from(DEFAULT_ENV_DENYLIST, (key) => (CASE_INSENSITIVE_ENV ? key.toUpperCase() : key)),
@@ -168,8 +168,9 @@ function filterEnv(env: Record<string, string | undefined>): Record<string, stri
 		if (value === undefined) continue;
 		const normalizedKey = normalizeEnvKey(key);
 		if (NORMALIZED_DENYLIST.has(normalizedKey)) continue;
-		if (NORMALIZED_ALLOWLIST.has(normalizedKey)) {
-			filtered[key] = value;
+		const canonicalKey = NORMALIZED_ALLOWLIST.get(normalizedKey);
+		if (canonicalKey !== undefined) {
+			filtered[canonicalKey] = value;
 			continue;
 		}
 		if (NORMALIZED_ALLOW_PREFIXES.some((prefix) => normalizedKey.startsWith(prefix))) {

package/src/core/ssh/ssh-executor.ts

@@ -95,7 +95,7 @@ export async function executeSSH(
 				return {
 					exitCode: undefined,
 					cancelled: true,
-					...sink.dump(`SSH command timed out after ${Math.round(options!.timeout! / 1000)} seconds`),
+					...sink.dump(`SSH: ${err.message}`),
 				};
 			}
 			if (err.aborted) {

package/src/core/tools/python.ts

@@ -64,6 +64,7 @@ export interface PythonToolDetails {
 	images?: ImageContent[];
 	/** Structured status events from prelude helpers */
 	statusEvents?: PythonStatusEvent[];
+	isError?: boolean;
 }
 
 function formatJsonScalar(value: unknown): string {

package/src/core/tools/task/executor.ts

@@ -343,7 +343,9 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	let abortSent = false;
 	let abortReason: AbortReason | undefined;
 	let terminationScheduled = false;
-	let pendingTerminationController: AbortController | null = null;
+	let terminated = false;
+	let terminationTimeoutId: ReturnType<typeof setTimeout> | null = null;
+	let pendingTerminationTimeoutId: ReturnType<typeof setTimeout> | null = null;
 	let finalize: ((message: Extract<SubagentWorkerResponse, { type: "done" }>) => void) | null = null;
 	const listenerController = new AbortController();
 	const listenerSignal = listenerController.signal;
@@ -416,28 +418,25 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 	const scheduleTermination = () => {
 		if (terminationScheduled) return;
 		terminationScheduled = true;
-		const timeoutSignal = AbortSignal.timeout(2000);
-		timeoutSignal.addEventListener(
-			"abort",
-			() => {
-				if (resolved) return;
-				try {
-					worker.terminate();
-				} catch {
-					// Ignore termination errors
-				}
-				if (finalize && !resolved) {
-					finalize({
-						type: "done",
-						exitCode: 1,
-						durationMs: Date.now() - startTime,
-						error: abortReason === "signal" ? "Aborted" : "Worker terminated after tool completion",
-						aborted: abortReason === "signal",
-					});
-				}
-			},
-			{ once: true, signal: listenerSignal },
-		);
+		terminationTimeoutId = setTimeout(() => {
+			terminationTimeoutId = null;
+			if (resolved || terminated) return;
+			terminated = true;
+			try {
+				worker.terminate();
+			} catch {
+				// Ignore termination errors
+			}
+			if (finalize && !resolved) {
+				finalize({
+					type: "done",
+					exitCode: 1,
+					durationMs: Date.now() - startTime,
+					error: abortReason === "signal" ? "Aborted" : "Worker terminated after tool completion",
+					aborted: abortReason === "signal",
+				});
+			}
+		}, 2000);
 	};
 
 	const requestAbort = (reason: AbortReason) => {
@@ -461,28 +460,25 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			// Worker already terminated, nothing to do
 		}
 		// Cancel pending termination if it exists
-		if (pendingTerminationController) {
-			pendingTerminationController.abort();
-			pendingTerminationController = null;
-		}
+		cancelPendingTermination();
 		scheduleTermination();
 	};
 
 	const schedulePendingTermination = () => {
-		if (pendingTerminationController || abortSent || terminationScheduled || resolved) return;
-		const readyController = new AbortController();
-		pendingTerminationController = readyController;
-		const pendingSignal = AbortSignal.any([AbortSignal.timeout(2000), readyController.signal]);
-		pendingSignal.addEventListener(
-			"abort",
-			() => {
-				pendingTerminationController = null;
-				if (!resolved) {
-					requestAbort("terminate");
-				}
-			},
-			{ once: true, signal: listenerSignal },
-		);
+		if (pendingTerminationTimeoutId || abortSent || terminationScheduled || resolved) return;
+		pendingTerminationTimeoutId = setTimeout(() => {
+			pendingTerminationTimeoutId = null;
+			if (!resolved) {
+				requestAbort("terminate");
+			}
+		}, 2000);
+	};
+
+	const cancelPendingTermination = () => {
+		if (pendingTerminationTimeoutId) {
+			clearTimeout(pendingTerminationTimeoutId);
+			pendingTerminationTimeoutId = null;
+		}
 	};
 
 	// Handle abort signal
@@ -655,9 +651,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					// Accumulate tokens for progress display
 					progress.tokens += getUsageTokens(messageUsage);
 				}
-				// If pending termination, now we have tokens - terminate
-				if (pendingTerminationController) {
-					pendingTerminationController.abort();
+				// If pending termination, now we have tokens - terminate immediately
+				if (pendingTerminationTimeoutId) {
+					cancelPendingTermination();
+					requestAbort("terminate");
 				}
 				break;
 			}
@@ -714,7 +711,6 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 	const done = await new Promise<Extract<SubagentWorkerResponse, { type: "done" }>>((resolve) => {
 		const cleanup = () => {
-			pendingTerminationController = null;
 			listenerController.abort();
 		};
 		finalize = (message) => {
@@ -723,10 +719,18 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			cleanup();
 			resolve(message);
 		};
+		const postMessageSafe = (message: unknown) => {
+			if (resolved || terminated) return;
+			try {
+				worker.postMessage(message);
+			} catch {
+				// Worker already terminated
+			}
+		};
 		const handleMCPCall = async (request: MCPToolCallRequest) => {
 			const mcpManager = options.mcpManager;
 			if (!mcpManager) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					error: "MCP not available",
@@ -743,13 +747,13 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					})(),
 					request.timeoutMs,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], isError: result.isError },
 				});
 			} catch (error) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "mcp_tool_result",
 					callId: request.callId,
 					error: error instanceof Error ? error.message : String(error),
@@ -767,7 +771,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		const handlePythonCall = async (request: PythonToolCallRequest) => {
 			if (!pythonTool) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					error: "Python proxy not available",
@@ -785,7 +789,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					request.params as { code: string; timeout?: number; workdir?: string; reset?: boolean },
 					combinedSignal,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], details: result.details },
@@ -797,7 +801,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						: error instanceof Error
 							? error.message
 							: String(error);
-				worker.postMessage({
+				postMessageSafe({
 					type: "python_tool_result",
 					callId: request.callId,
 					error: message,
@@ -816,7 +820,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 		const handleLspCall = async (request: LspToolCallRequest) => {
 			if (!lspTool) {
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					error: "LSP proxy not available",
@@ -828,7 +832,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					lspTool.execute(request.callId, request.params as LspParams, signal),
 					request.timeoutMs,
 				);
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					result: { content: result.content ?? [], details: result.details },
@@ -840,7 +844,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						: error instanceof Error
 							? error.message
 							: String(error);
-				worker.postMessage({
+				postMessageSafe({
 					type: "lsp_tool_result",
 					callId: request.callId,
 					error: message,
@@ -881,10 +885,14 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				return;
 			}
 			if (message.type === "done") {
+				// Worker is exiting - mark as terminated to prevent calling terminate() on dead worker
+				terminated = true;
 				finalize?.(message);
 			}
 		};
 		const onError = (event: WorkerErrorEvent) => {
+			// Worker error likely means it's dead or dying
+			terminated = true;
 			finalize?.({
 				type: "done",
 				exitCode: 1,
@@ -893,6 +901,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			});
 		};
 		const onMessageError = () => {
+			// Message error may indicate worker is in bad state
+			terminated = true;
 			finalize?.({
 				type: "done",
 				exitCode: 1,
@@ -902,6 +912,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		};
 		const onClose = () => {
 			// Worker terminated unexpectedly (crashed or was killed without sending done)
+			// Mark as terminated since the worker is already dead - calling terminate() again would crash
+			terminated = true;
 			const abortMessage =
 				abortSent && abortReason === "signal"
 					? "Worker terminated after abort"
@@ -932,11 +944,19 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		}
 	});
 
-	// Cleanup
-	try {
-		worker.terminate();
-	} catch {
-		// Ignore termination errors
+	// Cleanup - cancel any pending timeouts first
+	if (terminationTimeoutId) {
+		clearTimeout(terminationTimeoutId);
+		terminationTimeoutId = null;
+	}
+	cancelPendingTermination();
+	if (!terminated) {
+		terminated = true;
+		try {
+			worker.terminate();
+		} catch {
+			// Ignore termination errors
+		}
 	}
 
 	let exitCode = done.exitCode;

package/src/core/tools/task/worker.ts

@@ -15,7 +15,7 @@
 
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model } from "@oh-my-pi/pi-ai";
-import { logger, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, postmortem, untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import lspDescription from "../../../prompts/tools/lsp.md" with { type: "text" };
 import type { AgentSessionEvent } from "../../agent-session";
@@ -377,17 +377,29 @@ function createPythonProxyTool(): CustomTool<typeof pythonSchema> {
 		description: getPythonToolDescription(),
 		parameters: pythonSchema,
 		execute: async (_toolCallId, params, _onUpdate, _ctx, signal) => {
-			const timeoutMs = getPythonCallTimeoutMs(params as PythonToolParams);
-			const result = await callPythonToolViaParent(params as PythonToolParams, signal, timeoutMs);
-			return {
-				content:
-					result?.content?.map((c) =>
-						c.type === "text"
-							? { type: "text" as const, text: c.text ?? "" }
-							: { type: "text" as const, text: JSON.stringify(c) },
-					) ?? [],
-				details: result?.details as PythonToolDetails | undefined,
-			};
+			try {
+				const timeoutMs = getPythonCallTimeoutMs(params as PythonToolParams);
+				const result = await callPythonToolViaParent(params as PythonToolParams, signal, timeoutMs);
+				return {
+					content:
+						result?.content?.map((c) =>
+							c.type === "text"
+								? { type: "text" as const, text: c.text ?? "" }
+								: { type: "text" as const, text: JSON.stringify(c) },
+						) ?? [],
+					details: result?.details as PythonToolDetails | undefined,
+				};
+			} catch (error) {
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: `Python error: ${error instanceof Error ? error.message : String(error)}`,
+						},
+					],
+					details: { isError: true } as PythonToolDetails,
+				};
+			}
 		},
 	};
 }
@@ -780,7 +792,14 @@ function handleAbort(): void {
 	}
 }
 
-const reportFatal = (message: string): void => {
+const reportFatal = async (message: string): Promise<void> => {
+	// Run postmortem cleanup first to ensure child processes are killed
+	try {
+		await postmortem.cleanup();
+	} catch {
+		// Ignore cleanup errors
+	}
+
 	const runState = activeRun;
 	if (runState) {
 		runState.abortController.abort();
@@ -821,6 +840,16 @@ self.addEventListener("error", (event) => {
 self.addEventListener("unhandledrejection", (event) => {
 	const reason = event.reason;
 	const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+
+	// Avoid terminating active runs on tool-level errors that bubble as rejections.
+	if (activeRun) {
+		logger.error("Unhandled rejection in subagent worker", { error: message });
+		if ("preventDefault" in event && typeof event.preventDefault === "function") {
+			event.preventDefault();
+		}
+		return;
+	}
+
 	reportFatal(`Unhandled rejection: ${message}`);
 });
 

package/src/core/tools/web-fetch.ts

@@ -4,8 +4,8 @@ import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
+import { ptree } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
-import { $ } from "bun";
 import { nanoid } from "nanoid";
 import { parse as parseHtml } from "node-html-parser";
 import { type Theme, theme } from "../../modes/interactive/theme/theme";
@@ -75,18 +75,58 @@ const CONVERTIBLE_EXTENSIONS = new Set([
  * Execute a command and return stdout
  */
 
+type WritableLike = {
+	write: (chunk: string | Uint8Array) => unknown;
+	flush?: () => unknown;
+	end?: () => unknown;
+};
+
+const textEncoder = new TextEncoder();
+
+async function writeStdin(handle: unknown, input: string | Buffer): Promise<void> {
+	if (!handle || typeof handle === "number") return;
+	if (typeof (handle as WritableStream<Uint8Array>).getWriter === "function") {
+		const writer = (handle as WritableStream<Uint8Array>).getWriter();
+		try {
+			const chunk = typeof input === "string" ? textEncoder.encode(input) : new Uint8Array(input);
+			await writer.write(chunk);
+		} finally {
+			await writer.close();
+		}
+		return;
+	}
+
+	const sink = handle as WritableLike;
+	sink.write(input);
+	if (sink.flush) sink.flush();
+	if (sink.end) sink.end();
+}
+
 async function exec(
 	cmd: string,
 	args: string[],
 	options?: { timeout?: number; input?: string | Buffer },
 ): Promise<{ stdout: string; stderr: string; ok: boolean }> {
-	void options;
-	const result = await $`${cmd} ${args}`.quiet().nothrow();
-	const decoder = new TextDecoder();
+	const proc = ptree.cspawn([cmd, ...args], {
+		stdin: options?.input ? "pipe" : null,
+		timeout: options?.timeout,
+	});
+
+	if (options?.input) {
+		await writeStdin(proc.stdin, options.input);
+	}
+
+	const [stdout, stderr] = await Promise.all([proc.stdout.text(), proc.stderr.text()]);
+	try {
+		await proc.exited;
+	} catch {
+		// Handle non-zero exit or timeout
+	}
+
 	return {
-		stdout: result.stdout ? decoder.decode(result.stdout) : "",
-		stderr: result.stderr ? decoder.decode(result.stderr) : "",
-		ok: result.exitCode === 0,
+		stdout,
+		stderr,
+		ok: proc.exitCode === 0,
 	};
 }
 

package/src/main.ts

@@ -92,11 +92,13 @@ async function runInteractiveMode(
 
 	await mode.init();
 
-	versionCheckPromise.then((newVersion) => {
-		if (newVersion) {
-			mode.showNewVersionNotification(newVersion);
-		}
-	});
+	versionCheckPromise
+		.then((newVersion) => {
+			if (newVersion) {
+				mode.showNewVersionNotification(newVersion);
+			}
+		})
+		.catch(() => {});
 
 	mode.renderInitialMessages();
 

package/src/modes/interactive/components/login-dialog.ts

@@ -109,7 +109,9 @@ export class LoginDialogComponent extends Container {
 	showManualInput(prompt: string): Promise<string> {
 		this.contentContainer.addChild(new Spacer(1));
 		this.contentContainer.addChild(new Text(theme.fg("dim", prompt), 1, 0));
-		this.contentContainer.addChild(this.input);
+		if (!this.contentContainer.children.includes(this.input)) {
+			this.contentContainer.addChild(this.input);
+		}
 		this.contentContainer.addChild(new Text(theme.fg("dim", "(Escape to cancel)"), 1, 0));
 		this.tui.requestRender();
 
@@ -129,7 +131,9 @@ export class LoginDialogComponent extends Container {
 		if (placeholder) {
 			this.contentContainer.addChild(new Text(theme.fg("dim", `e.g., ${placeholder}`), 1, 0));
 		}
-		this.contentContainer.addChild(this.input);
+		if (!this.contentContainer.children.includes(this.input)) {
+			this.contentContainer.addChild(this.input);
+		}
 		this.contentContainer.addChild(new Text(theme.fg("dim", "(Escape to cancel, Enter to submit)"), 1, 0));
 
 		this.input.setValue("");

package/src/modes/interactive/components/tool-execution.ts

@@ -260,6 +260,10 @@ export class ToolExecutionComponent extends Container {
 	): void {
 		this.result = result;
 		this.isPartial = isPartial;
+		// When tool is complete, ensure args are marked complete so spinner stops
+		if (!isPartial) {
+			this.argsComplete = true;
+		}
 		this.updateSpinnerAnimation();
 		this.updateDisplay();
 		// Convert non-PNG images to PNG for Kitty protocol (async)

package/src/modes/interactive/interactive-mode.ts

@@ -168,6 +168,9 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.editor.onAutocompleteCancel = () => {
 			this.ui.requestRender(true);
 		};
+		this.editor.onAutocompleteUpdate = () => {
+			this.ui.requestRender(true);
+		};
 		try {
 			this.historyStorage = HistoryStorage.open();
 			this.editor.setHistoryStorage(this.historyStorage);