gsd-pi 2.8.3 → 2.10.0

package/src/resources/extensions/bg-shell/index.ts

@@ -16,7 +16,7 @@
  * - Context injection: proactive alerts for crashes and state changes
  *
  * Tools:
- *   bg_shell — start, output, digest, wait_for_ready, send, send_and_wait,
+ *   bg_shell — start, output, digest, wait_for_ready, send, send_and_wait, run,
  *              signal, list, kill, restart, group_status
  *
  * Commands:
@@ -88,7 +88,7 @@ type ProcessStatus =
 	| "exited"
 	| "crashed";
 
-type ProcessType = "server" | "build" | "test" | "watcher" | "generic";
+type ProcessType = "server" | "build" | "test" | "watcher" | "generic" | "shell";
 
 interface ProcessEvent {
 	type:
@@ -164,6 +164,8 @@ interface BgProcess {
 	lastErrorCount: number;
 	/** Last warning count snapshot for diff detection */
 	lastWarningCount: number;
+	/** Command history for shell-type sessions */
+	commandHistory: string[];
 	/** Dedup tracker: hash → count of repeated lines */
 	lineDedup: Map<string, number>;
 	/** Total raw lines (before dedup) for token savings calc */
@@ -583,7 +585,9 @@ function startProcess(opts: StartOptions): BgProcess {
 	const env = { ...process.env, ...(opts.env || {}) };
 
 	const { shell, args: shellArgs } = getShellConfig();
-	const proc = spawn(shell, [...shellArgs, sanitizeCommand(opts.command)], {
+	// Shell sessions default to the user's shell if no command specified
+	const command = processType === "shell" && !opts.command ? shell : opts.command;
+	const proc = spawn(shell, [...shellArgs, sanitizeCommand(command)], {
 		cwd: opts.cwd,
 		stdio: ["pipe", "pipe", "pipe"],
 		env,
@@ -592,8 +596,8 @@ function startProcess(opts: StartOptions): BgProcess {
 
 	const bg: BgProcess = {
 		id,
-		label: opts.label || opts.command.slice(0, 60),
-		command: opts.command,
+		label: opts.label || command.slice(0, 60),
+		command,
 		cwd: opts.cwd,
 		startedAt: Date.now(),
 		proc,
@@ -615,14 +619,15 @@ function startProcess(opts: StartOptions): BgProcess {
 		group: opts.group || null,
 		lastErrorCount: 0,
 		lastWarningCount: 0,
+		commandHistory: [],
 		lineDedup: new Map(),
 		totalRawLines: 0,
 		envKeys: Object.keys(opts.env || {}),
 		restartCount: 0,
 		startConfig: {
-			command: opts.command,
+			command,
 			cwd: opts.cwd,
-			label: opts.label || opts.command.slice(0, 60),
+			label: opts.label || command.slice(0, 60),
 			processType,
 			readyPattern: opts.readyPattern || null,
 			readyPort: opts.readyPort || null,
@@ -630,7 +635,7 @@ function startProcess(opts: StartOptions): BgProcess {
 		},
 	};
 
-	addEvent(bg, { type: "started", detail: `Process started: ${opts.command.slice(0, 100)}` });
+	addEvent(bg, { type: "started", detail: `Process started: ${command.slice(0, 100)}` });
 
 	proc.stdout?.on("data", (chunk: Buffer) => {
 		const lines = chunk.toString().split("\n");
@@ -687,6 +692,15 @@ function startProcess(opts: StartOptions): BgProcess {
 		startPortProbing(bg, bg.readyPort);
 	}
 
+	// Shell sessions are ready immediately after spawn
+	if (bg.processType === "shell") {
+		setTimeout(() => {
+			if (bg.alive && bg.status === "starting") {
+				transitionToReady(bg, "Shell session initialized");
+			}
+		}, 200);
+	}
+
 	processes.set(id, bg);
 	return bg;
 }
@@ -876,6 +890,73 @@ async function waitForReady(bg: BgProcess, timeout: number, signal?: AbortSignal
 	return { ready: false, detail: `Timed out after ${timeout}ms waiting for ready signal` };
 }
 
+// ── Query Shell Environment ────────────────────────────────────────────────
+
+async function queryShellEnv(
+	bg: BgProcess,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ cwd: string; env: Record<string, string>; shell: string } | null> {
+	const sentinel = `__GSD_ENV_${randomUUID().slice(0, 8)}__`;
+	const startIndex = bg.output.length;
+
+	const cmd = [
+		`echo "${sentinel}_START"`,
+		`echo "CWD=$(pwd)"`,
+		`echo "SHELL=$SHELL"`,
+		`echo "PATH=$PATH"`,
+		`echo "VIRTUAL_ENV=$VIRTUAL_ENV"`,
+		`echo "NODE_ENV=$NODE_ENV"`,
+		`echo "HOME=$HOME"`,
+		`echo "USER=$USER"`,
+		`echo "NVM_DIR=$NVM_DIR"`,
+		`echo "GOPATH=$GOPATH"`,
+		`echo "CARGO_HOME=$CARGO_HOME"`,
+		`echo "PYTHONPATH=$PYTHONPATH"`,
+		`echo "${sentinel}_END"`,
+	].join(" && ");
+
+	bg.proc.stdin?.write(cmd + "\n");
+
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (signal?.aborted) return null;
+		if (!bg.alive) return null;
+
+		const newEntries = bg.output.slice(startIndex);
+		const endIdx = newEntries.findIndex(e => e.line.includes(`${sentinel}_END`));
+		if (endIdx >= 0) {
+			const startIdx = newEntries.findIndex(e => e.line.includes(`${sentinel}_START`));
+			if (startIdx >= 0) {
+				const envLines = newEntries.slice(startIdx + 1, endIdx);
+				const env: Record<string, string> = {};
+				let cwd = "";
+				let shell = "";
+
+				for (const entry of envLines) {
+					const match = entry.line.match(/^([A-Z_]+)=(.*)$/);
+					if (match) {
+						const [, key, value] = match;
+						if (key === "CWD") {
+							cwd = value;
+						} else if (key === "SHELL") {
+							shell = value;
+						} else if (value) {
+							env[key] = value;
+						}
+					}
+				}
+
+				return { cwd, env, shell };
+			}
+		}
+
+		await new Promise(r => setTimeout(r, 100));
+	}
+
+	return null;
+}
+
 // ── Send and Wait ──────────────────────────────────────────────────────────
 
 async function sendAndWait(
@@ -915,6 +996,92 @@ async function sendAndWait(
 	return { matched: false, output: newEntries.map(e => e.line).join("\n") || "(no output)" };
 }
 
+// ── Run on Session ─────────────────────────────────────────────────────────
+
+async function runOnSession(
+	bg: BgProcess,
+	command: string,
+	timeout: number,
+	signal?: AbortSignal,
+): Promise<{ exitCode: number; output: string; timedOut: boolean }> {
+	const sentinel = randomUUID().slice(0, 8);
+	const startMarker = `__GSD_SENTINEL_${sentinel}_START__`;
+	const endMarker = `__GSD_SENTINEL_${sentinel}_END__`;
+	const exitVar = `__GSD_EXIT_${sentinel}__`;
+
+	// Snapshot current output buffer position
+	const startIndex = bg.output.length;
+
+	// Write the sentinel-wrapped command to stdin
+	const wrappedCommand = [
+		`echo ${startMarker}`,
+		command,
+		`${exitVar}=$?`,
+		`echo ${endMarker} $${exitVar}`,
+	].join("\n");
+	bg.proc.stdin?.write(wrappedCommand + "\n");
+
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (signal?.aborted) {
+			const newEntries = bg.output.slice(startIndex);
+			return { exitCode: -1, output: newEntries.map(e => e.line).join("\n") || "(cancelled)", timedOut: false };
+		}
+
+		// Process died while waiting
+		if (!bg.alive) {
+			const newEntries = bg.output.slice(startIndex);
+			const lines = newEntries.map(e => e.line);
+			return { exitCode: bg.proc.exitCode ?? -1, output: lines.join("\n") || "(process exited)", timedOut: false };
+		}
+
+		const newEntries = bg.output.slice(startIndex);
+		for (let i = 0; i < newEntries.length; i++) {
+			if (newEntries[i].line.includes(endMarker)) {
+				// Parse exit code from the END sentinel line
+				const endLine = newEntries[i].line;
+				const exitMatch = endLine.match(new RegExp(`${endMarker}\\s+(\\d+)`));
+				const exitCode = exitMatch ? parseInt(exitMatch[1], 10) : -1;
+
+				// Extract output between START and END sentinels
+				const outputLines: string[] = [];
+				let capturing = false;
+				for (let j = 0; j < newEntries.length; j++) {
+					if (newEntries[j].line.includes(startMarker)) {
+						capturing = true;
+						continue;
+					}
+					if (newEntries[j].line.includes(endMarker)) {
+						break;
+					}
+					if (capturing) {
+						outputLines.push(newEntries[j].line);
+					}
+				}
+
+				return { exitCode, output: outputLines.join("\n"), timedOut: false };
+			}
+		}
+
+		await new Promise(r => setTimeout(r, 100));
+	}
+
+	// Timed out
+	const newEntries = bg.output.slice(startIndex);
+	const outputLines: string[] = [];
+	let capturing = false;
+	for (const entry of newEntries) {
+		if (entry.line.includes(startMarker)) {
+			capturing = true;
+			continue;
+		}
+		if (capturing) {
+			outputLines.push(entry.line);
+		}
+	}
+	return { exitCode: -1, output: outputLines.join("\n") || "(no output)", timedOut: true };
+}
+
 // ── Group Operations ───────────────────────────────────────────────────────
 
 function getGroupProcesses(group: string): BgProcess[] {
@@ -1011,8 +1178,11 @@ function formatTimeAgo(timestamp: number): string {
 function pruneDeadProcesses(): void {
 	const now = Date.now();
 	for (const [id, bg] of processes) {
-		if (!bg.alive && now - bg.startedAt > DEAD_PROCESS_TTL) {
-			processes.delete(id);
+		if (!bg.alive) {
+			const ttl = bg.processType === "shell" ? DEAD_PROCESS_TTL * 6 : DEAD_PROCESS_TTL;
+			if (now - bg.startedAt > ttl) {
+				processes.delete(id);
+			}
 		}
 	}
 }
@@ -1175,6 +1345,8 @@ export default function (pi: ExtensionAPI) {
 			"Actions: start (launch with auto-classification & readiness detection), digest (structured summary ~30 tokens vs ~2000 raw), " +
 			"output (raw lines with incremental delivery), wait_for_ready (block until process signals readiness), " +
 			"send (write stdin), send_and_wait (expect-style: send + wait for output pattern), " +
+			"run (execute a command on a persistent shell session, block until done, return output + exit code), " +
+			"env (query shell cwd and environment variables), " +
 			"signal (send OS signal), list (all processes with status), kill (terminate), restart (kill + relaunch), " +
 			"group_status (health of a process group), highlights (significant output lines only).",
 
@@ -1187,10 +1359,13 @@ export default function (pi: ExtensionAPI) {
 			"The 'output' action returns only new output since the last check (incremental). Repeated calls are cheap on context.",
 			"Set type:'server' and ready_port:3000 for dev servers so readiness detection is automatic.",
 			"Set group:'my-stack' on related processes to manage them together with 'group_status'.",
+			"Use 'run' to execute a command on a persistent shell session and block until it completes — returns structured output + exit code. Shell state (env vars, cwd, virtualenvs) persists across runs.",
 			"Use 'send_and_wait' for interactive CLIs: send input and wait for expected output pattern.",
+			"Use 'env' to check the current working directory and active environment variables of a shell session — useful after cd, source, or export commands.",
 			"Use 'restart' to kill and relaunch with the same config — preserves restart count.",
 			"Background processes are auto-classified (server/build/test/watcher) based on the command.",
 			"Process crashes and errors are automatically surfaced as alerts at the start of your next turn — you don't need to poll.",
+			"To create a persistent shell session: bg_shell start with type:'shell'. The session stays alive for interactive use with 'send', 'send_and_wait', or 'run'.",
 		],
 
 		parameters: Type.Object({
@@ -1202,6 +1377,8 @@ export default function (pi: ExtensionAPI) {
 				"wait_for_ready",
 				"send",
 				"send_and_wait",
+				"run",
+				"env",
 				"signal",
 				"list",
 				"kill",
@@ -1209,13 +1386,13 @@ export default function (pi: ExtensionAPI) {
 				"group_status",
 			] as const),
 			command: Type.Optional(
-				Type.String({ description: "Shell command to run (for start)" }),
+				Type.String({ description: "Shell command to run (for start, run)" }),
 			),
 			label: Type.Optional(
 				Type.String({ description: "Short human-readable label for the process (for start)" }),
 			),
 			id: Type.Optional(
-				Type.String({ description: "Process ID (for digest, output, highlights, wait_for_ready, send, send_and_wait, signal, kill, restart)" }),
+				Type.String({ description: "Process ID (for digest, output, highlights, wait_for_ready, send, send_and_wait, run, signal, kill, restart)" }),
 			),
 			stream: Type.Optional(
 				StringEnum(["stdout", "stderr", "both"] as const),
@@ -1236,10 +1413,10 @@ export default function (pi: ExtensionAPI) {
 				Type.String({ description: "OS signal to send, e.g. SIGINT, SIGTERM, SIGHUP (for signal)" }),
 			),
 			timeout: Type.Optional(
-				Type.Number({ description: "Timeout in milliseconds (for wait_for_ready, send_and_wait). Default: 30000" }),
+				Type.Number({ description: "Timeout in milliseconds (for wait_for_ready, send_and_wait, run). Default: 30000 for wait_for_ready/send_and_wait, 120000 for run" }),
 			),
 			type: Type.Optional(
-				StringEnum(["server", "build", "test", "watcher", "generic"] as const),
+				StringEnum(["server", "build", "test", "watcher", "generic", "shell"] as const),
 			),
 			ready_pattern: Type.Optional(
 				Type.String({ description: "Regex pattern that indicates the process is ready (for start)" }),
@@ -1261,7 +1438,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.command) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'command' is required for start" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1316,7 +1493,7 @@ export default function (pi: ExtensionAPI) {
 						if (!bg) {
 							return {
 								content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-								isError: true,
+								isError: true, details: undefined as unknown,
 							};
 						}
 						const digest = generateDigest(bg, true);
@@ -1356,7 +1533,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for highlights" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1364,7 +1541,7 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1388,7 +1565,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for output" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1396,7 +1573,7 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1429,7 +1606,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for wait_for_ready" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1437,7 +1614,7 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1472,13 +1649,13 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for send" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 					if (params.input === undefined) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'input' is required for send" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1486,14 +1663,14 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
 					if (!bg.alive) {
 						return {
 							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1506,7 +1683,7 @@ export default function (pi: ExtensionAPI) {
 					} catch (err) {
 						return {
 							content: [{ type: "text" as const, text: `Error writing to stdin: ${err instanceof Error ? err.message : String(err)}` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 				}
@@ -1516,19 +1693,19 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for send_and_wait" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 					if (params.input === undefined) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'input' is required for send_and_wait" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 					if (!params.wait_pattern) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'wait_pattern' is required for send_and_wait" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1536,14 +1713,14 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
 					if (!bg.alive) {
 						return {
 							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1563,12 +1740,111 @@ export default function (pi: ExtensionAPI) {
 					};
 				}
 
+				// ── run ────────────────────────────────────────────
+				case "run": {
+					if (!params.id) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'id' is required for run" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+					if (!params.command) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'command' is required for run" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const bg = processes.get(params.id);
+					if (!bg) {
+						return {
+							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					if (!bg.alive) {
+						return {
+							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const runTimeout = params.timeout || 120000;
+					const result = await runOnSession(bg, params.command, runTimeout, signal ?? undefined);
+
+					let text: string;
+					if (result.timedOut) {
+						text = `Command timed out after ${runTimeout}ms\nOutput:\n${result.output}`;
+					} else {
+						text = `Exit code: ${result.exitCode}\n${result.output}`;
+					}
+
+					return {
+						content: [{ type: "text" as const, text }],
+						details: { action: "run", process: getInfo(bg), exitCode: result.exitCode, timedOut: result.timedOut },
+					};
+				}
+
+				// ── env ───────────────────────────────────────────
+				case "env": {
+					if (!params.id) {
+						return {
+							content: [{ type: "text" as const, text: "Error: 'id' is required for env" }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const bg = processes.get(params.id);
+					if (!bg) {
+						return {
+							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					if (!bg.alive) {
+						return {
+							content: [{ type: "text" as const, text: `Error: Process ${params.id} has already exited` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					const timeout = params.timeout || 5000;
+					const envResult = await queryShellEnv(bg, timeout, signal ?? undefined);
+
+					if (!envResult) {
+						return {
+							content: [{ type: "text" as const, text: `Failed to query environment for process ${bg.id} (timed out or process died)` }],
+							isError: true, details: undefined as unknown,
+						};
+					}
+
+					let text = `Shell environment for ${bg.id} (${bg.label}):\n`;
+					text += `  cwd: ${envResult.cwd}\n`;
+					text += `  shell: ${envResult.shell}\n`;
+
+					const envEntries = Object.entries(envResult.env);
+					if (envEntries.length > 0) {
+						text += `  environment:\n`;
+						for (const [key, value] of envEntries) {
+							const displayValue = value.length > 100 ? value.slice(0, 97) + "..." : value;
+							text += `    ${key}=${displayValue}\n`;
+						}
+					}
+
+					return {
+						content: [{ type: "text" as const, text: text.trimEnd() }],
+						details: { action: "env", process: getInfo(bg), env: envResult },
+					};
+				}
+
 				// ── signal ─────────────────────────────────────────
 				case "signal": {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for signal" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1576,7 +1852,7 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1621,7 +1897,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for kill" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1629,7 +1905,7 @@ export default function (pi: ExtensionAPI) {
 					if (!bg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1657,7 +1933,7 @@ export default function (pi: ExtensionAPI) {
 					if (!params.id) {
 						return {
 							content: [{ type: "text" as const, text: "Error: 'id' is required for restart" }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1665,7 +1941,7 @@ export default function (pi: ExtensionAPI) {
 					if (!newBg) {
 						return {
 							content: [{ type: "text" as const, text: `Error: No process found with id '${params.id}'` }],
-							isError: true,
+							isError: true, details: undefined as unknown,
 						};
 					}
 
@@ -1732,7 +2008,7 @@ export default function (pi: ExtensionAPI) {
 				default:
 					return {
 						content: [{ type: "text" as const, text: `Unknown action: ${params.action}` }],
-						isError: true,
+						isError: true, details: undefined as unknown,
 					};
 			}
 		},
@@ -1760,7 +2036,7 @@ export default function (pi: ExtensionAPI) {
 
 			const action = details.action as string;
 
-			if (result.isError) {
+			if ((result as any).isError) {
 				const text = result.content[0];
 				return new Text(
 					theme.fg("error", text?.type === "text" ? text.text : "Error"),
@@ -1883,6 +2159,40 @@ export default function (pi: ExtensionAPI) {
 					);
 				}
 
+				case "run": {
+					const proc = details.process as BgProcessInfo;
+					const exitCode = details.exitCode as number;
+					const timedOut = details.timedOut as boolean;
+					if (timedOut) {
+						let text = theme.fg("warning", "⏱ Timed out ") + theme.fg("accent", proc.id);
+						if (expanded) {
+							const rawText = result.content[0];
+							if (rawText?.type === "text") {
+								const lines = rawText.text.split("\n").slice(1);
+								for (const line of lines.slice(0, 30)) {
+									text += "\n  " + theme.fg("toolOutput", line);
+								}
+							}
+						}
+						return new Text(text, 0, 0);
+					}
+					const icon = exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
+					let text = `${icon} ${theme.fg("accent", proc.id)} ${theme.fg("dim", `exit:${exitCode}`)}`;
+					if (expanded) {
+						const rawText = result.content[0];
+						if (rawText?.type === "text") {
+							const lines = rawText.text.split("\n").slice(1);
+							for (const line of lines.slice(0, 30)) {
+								text += "\n  " + theme.fg("toolOutput", line);
+							}
+							if (lines.length > 30) {
+								text += `\n  ${theme.fg("dim", `... ${lines.length - 30} more lines`)}`;
+							}
+						}
+					}
+					return new Text(text, 0, 0);
+				}
+
 				case "signal": {
 					const sig = details.signal as string;
 					const proc = details.process as BgProcessInfo;
@@ -1926,6 +2236,25 @@ export default function (pi: ExtensionAPI) {
 					);
 				}
 
+				case "env": {
+					const proc = details.process as BgProcessInfo;
+					const envData = details.env as { cwd: string; shell: string } | undefined;
+					let text = theme.fg("accent", proc.id) + " " + theme.fg("muted", proc.label);
+					if (envData) {
+						text += " " + theme.fg("dim", `cwd: ${envData.cwd}`);
+					}
+					if (expanded) {
+						const rawText = result.content[0];
+						if (rawText?.type === "text") {
+							const lines = rawText.text.split("\n").slice(1);
+							for (const line of lines.slice(0, 15)) {
+								text += "\n  " + theme.fg("dim", line);
+							}
+						}
+					}
+					return new Text(text, 0, 0);
+				}
+
 				case "group_status": {
 					const gs = details.groupStatus as ReturnType<typeof getGroupStatus> | undefined;
 					if (gs) {
@@ -2338,17 +2667,14 @@ export default function (pi: ExtensionAPI) {
 	}, 2000);
 
 	// Refresh widget after agent actions and session events
-	for (const event of [
-		"turn_end",
-		"agent_end",
-		"session_start",
-		"session_switch",
-	] as const) {
-		pi.on(event, async (_event: unknown, ctx: ExtensionContext) => {
-			latestCtx = ctx;
-			refreshWidget();
-		});
-	}
+	const refreshHandler = async (_event: unknown, ctx: ExtensionContext) => {
+		latestCtx = ctx;
+		refreshWidget();
+	};
+	pi.on("turn_end", refreshHandler as any);
+	pi.on("agent_end", refreshHandler as any);
+	pi.on("session_start", refreshHandler as any);
+	pi.on("session_switch", refreshHandler as any);
 
 	pi.on("tool_execution_end", async (_event, ctx) => {
 		latestCtx = ctx;