feat: interactive shell streaming with live output and quiesce detection

Replace batch-output shell execution with spawn-based streaming:
- Shell commands now stream output line-by-line via ProcessEvent::ToolOutput
- 5-second quiesce detection kills interactive prompts (waiting_for_input)
- Frontend renders live output in ToolCall component with auto-scroll
- ToolOutput events broadcast via separate SSE channel (capacity 1024)
- Timeout enforcement wraps entire streaming operation
- Watchdog now kills child process when quiesce detected

Fixes:
- P1: Timeout was ignored in streaming mode (now enforced)
- P1: Watchdog didn't kill child (now passes Arc<Mutex<Child>>)
- P2: Frontend call_id mismatch (now uses pendingToolCallIdsRef)

Files changed:
- src/tools/shell.rs: Complete rewrite with streaming
- src/lib.rs: Add ProcessEvent::ToolOutput variant
- src/api/state.rs: Wire SSE for tool_output events
- interface/: Live output rendering components
- prompts/: Interactive guidance for LLM

Author: vsumner

interface/src/api/client.ts

@@ -199,6 +199,19 @@ export interface ToolStartedEvent {
 	args: string;
 }
 
+export interface ToolOutputEvent {
+	type: "tool_output";
+	agent_id: string;
+	channel_id: string | null;
+	process_type: string;
+	process_id: string;
+	/** Stable identifier matching the tool_call that initiated this stream. */
+	call_id: string;
+	tool_name: string;
+	line: string;
+	stream: "stdout" | "stderr";
+}
+
 export interface ToolCompletedEvent {
 	type: "tool_completed";
 	agent_id: string;
@@ -267,6 +280,7 @@ export type ApiEvent =
 	| BranchCompletedEvent
 	| ToolStartedEvent
 	| ToolCompletedEvent
+	| ToolOutputEvent
 	| OpenCodePartUpdatedEvent
 	| WorkerTextEvent
 	| CortexChatMessageEvent;

interface/src/components/ToolCall.tsx

@@ -1,6 +1,15 @@
 import {useState} from "react";
 import {cx} from "class-variance-authority";
-import type {TranscriptStep, OpenCodePart} from "@/api/client";
+import type {OpenCodePart} from "@/api/client";
+import type { TranscriptStep as SchemaTranscriptStep } from "@/api/types";
+
+// Extended TranscriptStep with live_output for streaming shell output
+type ExtendedTranscriptStep = SchemaTranscriptStep & {
+	live_output?: string;
+};
+
+// Use the extended type for pairing
+type TranscriptStep = ExtendedTranscriptStep;
 
 // ---------------------------------------------------------------------------
 // Types
@@ -25,6 +34,8 @@ export interface ToolCallPair {
 	status: ToolCallStatus;
 	/** Human-readable summary provided by live opencode parts */
 	title?: string | null;
+	/** Live streaming output from tool_output SSE events (running tools only) */
+	liveOutput?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -42,12 +53,13 @@ export type TranscriptItem =
 
 export function pairTranscriptSteps(steps: TranscriptStep[]): TranscriptItem[] {
 	const items: TranscriptItem[] = [];
-	const resultsById = new Map<string, {name: string; text: string}>();
+	const resultsById = new Map<string, {name: string; text: string; liveOutput?: string}>();
 
 	// First pass: index all tool_result steps by call_id
 	for (const step of steps) {
 		if (step.type === "tool_result") {
-			resultsById.set(step.call_id, {name: step.name, text: step.text});
+			const liveOutput = step.live_output;
+			resultsById.set(step.call_id, {name: step.name, text: step.text, liveOutput});
 		}
 	}
 
@@ -77,6 +89,7 @@ export function pairTranscriptSteps(steps: TranscriptStep[]): TranscriptItem[] {
 							resultRaw: result?.text ?? null,
 							result: parsedResult,
 							status: result ? (isError ? "error" : "completed") : "running",
+							liveOutput: result?.liveOutput,
 						},
 					});
 				}
@@ -378,6 +391,15 @@ const toolRenderers: Record<string, ToolRenderer> = {
 			);
 		},
 		resultView(pair) {
+			if (pair.status === "running" && pair.liveOutput) {
+				return (
+					<div className="px-3 py-2">
+						<pre className="max-h-60 overflow-auto whitespace-pre-wrap font-mono text-tiny text-ink-dull">
+							{pair.liveOutput}
+						</pre>
+					</div>
+				);
+			}
 			if (!pair.resultRaw) return null;
 			return <ShellResultView pair={pair} />;
 		},
@@ -1118,6 +1140,15 @@ function renderResult(
 	renderer: ToolRenderer,
 ): React.ReactNode {
 	if (pair.status === "running") {
+		if (pair.liveOutput) {
+			return (
+				<div className="px-3 py-2">
+					<pre className="max-h-60 overflow-auto whitespace-pre-wrap font-mono text-tiny text-ink-dull">
+						{pair.liveOutput}
+					</pre>
+				</div>
+			);
+		}
 		return (
 			<div className="flex items-center gap-2 px-3 py-2 text-tiny text-ink-faint">
 				<span className="h-1.5 w-1.5 animate-pulse rounded-full bg-accent" />

interface/src/hooks/useLiveContext.tsx

@@ -1,6 +1,12 @@
 import { createContext, useContext, useCallback, useEffect, useRef, useState, useMemo, type ReactNode } from "react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { api, type AgentMessageEvent, type ChannelInfo, type ToolStartedEvent, type ToolCompletedEvent, type TranscriptStep, type OpenCodePart, type OpenCodePartUpdatedEvent, type WorkerTextEvent } from "@/api/client";
+import { api, type AgentMessageEvent, type ChannelInfo, type ToolStartedEvent, type ToolCompletedEvent, type ToolOutputEvent, type OpenCodePart, type OpenCodePartUpdatedEvent, type WorkerTextEvent } from "@/api/client";
+import type { TranscriptStep as SchemaTranscriptStep } from "@/api/types";
+
+/** Extended TranscriptStep with live_output for streaming shell output */
+type TranscriptStep = SchemaTranscriptStep & {
+	live_output?: string;
+};
 import { generateId } from "@/lib/id";
 import { useEventSource, type ConnectionState } from "@/hooks/useEventSource";
 import { useChannelLiveState, type ChannelLiveState, type ActiveWorker } from "@/hooks/useChannelLiveState";
@@ -230,6 +236,39 @@ export function LiveContextProvider({ children, onBootstrapped }: { children: Re
 		}
 	}, [channelHandlers, bumpWorkerVersion]);
 
+	const handleToolOutput = useCallback((data: unknown) => {
+		const event = data as ToolOutputEvent;
+		if (event.process_type === "worker") {
+			setLiveTranscripts((prev) => {
+				const steps = prev[event.process_id] ?? [];
+				// Use the stable call_id from the event to find or create the result step
+				const existingIndex = steps.findIndex(
+					(s) => s.type === "tool_result" && s.call_id === event.call_id
+				);
+				if (existingIndex >= 0) {
+					// Append to existing result step
+					const step = steps[existingIndex];
+					const existingOutput = (step as TranscriptStep).live_output ?? "";
+					const newOutput = existingOutput + event.line + "\n";
+					const updatedStep = { ...step, live_output: newOutput };
+					const newSteps = [...steps];
+					newSteps[existingIndex] = updatedStep;
+					return { ...prev, [event.process_id]: newSteps };
+				}
+				// Create new result step with the event's call_id
+				const step: TranscriptStep = {
+					type: "tool_result",
+					call_id: event.call_id,
+					name: event.tool_name,
+					text: "",
+					live_output: event.line + "\n",
+				};
+				return { ...prev, [event.process_id]: [...steps, step] };
+			});
+			bumpWorkerVersion();
+		}
+	}, [bumpWorkerVersion]);
+
 	// Handle OpenCode part updates — upsert parts into the per-worker ordered map
 	const handleOpenCodePartUpdated = useCallback((data: unknown) => {
 		const event = data as OpenCodePartUpdatedEvent;
@@ -280,6 +319,7 @@ export function LiveContextProvider({ children, onBootstrapped }: { children: Re
 			worker_completed: wrappedWorkerCompleted,
 			tool_started: wrappedToolStarted,
 			tool_completed: wrappedToolCompleted,
+			tool_output: handleToolOutput,
 			opencode_part_updated: handleOpenCodePartUpdated,
 			worker_text: handleWorkerText,
 			agent_message_sent: handleAgentMessage,
@@ -289,7 +329,7 @@ export function LiveContextProvider({ children, onBootstrapped }: { children: Re
 			notification_created: handleNotificationCreated,
 			notification_updated: handleNotificationUpdated,
 		}),
-		[channelHandlers, wrappedWorkerStarted, wrappedWorkerStatus, wrappedWorkerIdle, wrappedWorkerCompleted, wrappedToolStarted, wrappedToolCompleted, handleOpenCodePartUpdated, handleWorkerText, handleAgentMessage, bumpTaskVersion, handleCortexChatMessage, handleNotificationCreated, handleNotificationUpdated],
+		[channelHandlers, wrappedWorkerStarted, wrappedWorkerStatus, wrappedWorkerIdle, wrappedWorkerCompleted, wrappedToolStarted, wrappedToolCompleted, handleToolOutput, handleOpenCodePartUpdated, handleWorkerText, handleAgentMessage, bumpTaskVersion, handleCortexChatMessage, handleNotificationCreated, handleNotificationUpdated],
 	);
 
 	const onReconnect = useCallback(() => {

interface/src/lib/primitives.tsx

@@ -0,0 +1,180 @@
+import * as React from "react";
+import {cx} from "class-variance-authority";
+import {
+	Banner as PrimitiveBanner,
+	Button as PrimitiveButton,
+	FilterButton as PrimitiveFilterButton,
+	NumberStepper as PrimitiveNumberStepper,
+} from "../../node_modules/@spacedrive/primitives/dist/index.js";
+
+export * from "../../node_modules/@spacedrive/primitives/dist/index.js";
+
+type LegacyButtonVariant = "ghost" | "secondary" | "destructive";
+type PrimitiveButtonVariant = NonNullable<
+	React.ComponentProps<typeof PrimitiveButton>["variant"]
+>;
+type PrimitiveButtonSize = React.ComponentProps<typeof PrimitiveButton>["size"];
+type PrimitiveButtonRounding =
+	React.ComponentProps<typeof PrimitiveButton>["rounding"];
+type ButtonVariant = PrimitiveButtonVariant | LegacyButtonVariant;
+type CompatButtonBaseProps = {
+	children?: React.ReactNode;
+	className?: string;
+	loading?: boolean;
+	rounding?: PrimitiveButtonRounding;
+	size?: PrimitiveButtonSize;
+	variant?: ButtonVariant;
+};
+type CompatActionButtonProps = CompatButtonBaseProps &
+	Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "children"> & {
+		href?: undefined;
+	};
+type CompatLinkButtonProps = CompatButtonBaseProps &
+	Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, "children"> & {
+		href: string;
+	};
+type CompatButtonProps = CompatActionButtonProps | CompatLinkButtonProps;
+
+function hasHref(
+	props: CompatButtonProps,
+): props is CompatLinkButtonProps {
+	return "href" in props && props.href !== undefined;
+}
+
+function mapButtonVariant(
+	variant: ButtonVariant | undefined,
+): PrimitiveButtonVariant | undefined {
+	switch (variant) {
+		case "ghost":
+			return "subtle";
+		case "secondary":
+			return "gray";
+		case "destructive":
+			return "outline";
+		default:
+			return variant;
+	}
+}
+
+function legacyButtonClassName(variant: ButtonVariant | undefined) {
+	if (variant === "destructive") {
+		return "border-red-500/40 text-red-300 hover:border-red-500/60 hover:bg-red-500/10";
+	}
+
+	return undefined;
+}
+
+function LoadingSpinner() {
+	return (
+		<span
+			aria-hidden="true"
+			className="inline-block size-3 shrink-0 animate-spin rounded-full border border-current border-t-transparent"
+		/>
+	);
+}
+
+export const Button = React.forwardRef<
+	React.ElementRef<typeof PrimitiveButton>,
+	CompatButtonProps
+>(({variant, loading = false, className, children, ...props}, ref) => {
+	const buttonClassName = cx(legacyButtonClassName(variant), className);
+	const buttonVariant = mapButtonVariant(variant);
+	const content = (
+		<>
+			{loading ? <LoadingSpinner /> : null}
+			{children}
+		</>
+	);
+
+	if (hasHref(props)) {
+		return (
+			<PrimitiveButton
+				{...props}
+				ref={ref}
+				variant={buttonVariant}
+				className={buttonClassName}
+			>
+				{content}
+			</PrimitiveButton>
+		);
+	}
+
+	const actionProps = props as CompatActionButtonProps;
+
+	return (
+		<PrimitiveButton
+			{...actionProps}
+			ref={ref}
+			disabled={loading || actionProps.disabled}
+			aria-busy={loading || undefined}
+			variant={buttonVariant}
+			className={buttonClassName}
+		>
+			{content}
+		</PrimitiveButton>
+	);
+});
+
+Button.displayName = "Button";
+
+type BannerDotMode = "pulse" | "static";
+type CompatBannerProps = React.ComponentProps<typeof PrimitiveBanner> & {
+	dot?: BannerDotMode;
+};
+
+export const Banner = React.forwardRef<
+	React.ElementRef<typeof PrimitiveBanner>,
+	CompatBannerProps
+>(({dot, showDot, className, ...props}, ref) => (
+	<PrimitiveBanner
+		{...props}
+		ref={ref}
+		showDot={showDot ?? dot !== undefined}
+		className={cx(
+			dot === "pulse" && "[&>span:first-child]:animate-pulse",
+			className,
+		)}
+	/>
+));
+
+Banner.displayName = "Banner";
+
+type CompatFilterButtonProps = React.ComponentProps<
+	typeof PrimitiveFilterButton
+> & {
+	colorClass?: string;
+};
+
+export const FilterButton = React.forwardRef<
+	React.ElementRef<typeof PrimitiveFilterButton>,
+	CompatFilterButtonProps
+>(({colorClass, active, className, ...props}, ref) => (
+	<PrimitiveFilterButton
+		{...props}
+		ref={ref}
+		active={active}
+		className={cx(active && colorClass, className)}
+	/>
+));
+
+FilterButton.displayName = "FilterButton";
+
+type CompatNumberStepperProps = React.ComponentProps<
+	typeof PrimitiveNumberStepper
+> & {
+	type?: "float" | "int";
+	variant?: string;
+};
+
+export const NumberStepper = React.forwardRef<
+	React.ElementRef<typeof PrimitiveNumberStepper>,
+	CompatNumberStepperProps
+>(({type, variant: _variant, allowFloat, ...props}, ref) => (
+	<PrimitiveNumberStepper
+		{...props}
+		ref={ref}
+		allowFloat={allowFloat ?? type === "float"}
+	/>
+));
+
+NumberStepper.displayName = "NumberStepper";

prompts/en/tools/shell_description.md.j2

@@ -2,4 +2,6 @@ Execute a shell command. Use this for file operations, running scripts, building
 
 Use the optional `env` parameter to set per-command environment variables (e.g. `[{"key": "RUST_LOG", "value": "debug"}]`). Dangerous variables that enable library injection (LD_PRELOAD, NODE_OPTIONS, etc.) are blocked.
 
-To install tools that persist across restarts, place binaries in the persistent tools directory at $SPACEBOT_DIR/tools/bin (already on PATH). For example: `curl -fsSL https://example.com/tool -o $SPACEBOT_DIR/tools/bin/tool && chmod +x $SPACEBOT_DIR/tools/bin/tool`
+To install tools that persist across restarts, place binaries in the persistent tools directory at $SPACEBOT_DIR/tools/bin (already on PATH). For example: `curl -fsSL https://example.com/tool -o $SPACEBOT_DIR/tools/bin/tool && chmod +x $SPACEBOT_DIR/tools/bin/tool`
+
+Commands have no stdin — interactive prompts cannot be answered. If a command waits for input (no output for 5 seconds), it will be killed and you will receive `waiting_for_input: true` with the captured prompt text. To avoid this, always pass `--yes`, `-y`, or `--non-interactive` flags, or pipe input (e.g. `echo y | command`). The environment already sets `CI=true` and `DEBIAN_FRONTEND=noninteractive`.

prompts/en/worker.md.j2

@@ -87,6 +87,8 @@ Examples:
 
 Execute shell commands. Use this for running builds, tests, git operations, package management, and any system commands. Supports optional `env` parameter for setting per-command environment variables (e.g. `RUST_LOG=debug`).
 
+Commands have no stdin. Interactive prompts (confirmations, license acceptances) will be detected and killed after 5 seconds of silence. Always use `--yes`, `-y`, `--non-interactive`, or pipe input (e.g. `echo y | apt install foo`) to bypass prompts. The environment already sets `CI=true` and `DEBIAN_FRONTEND=noninteractive`.
+
 ### File tools (file_read, file_write, file_edit, file_list)
 
 Four separate tools for file operations:

src/agent/channel_history.rs

@@ -467,7 +467,8 @@ pub(crate) fn event_is_for_channel(event: &ProcessEvent, channel_id: &ChannelId)
         | ProcessEvent::StatusUpdate { .. }
         | ProcessEvent::TaskUpdated { .. }
         | ProcessEvent::WorkerText { .. }
-        | ProcessEvent::CortexChatUpdate { .. } => false,
+        | ProcessEvent::CortexChatUpdate { .. }
+        | ProcessEvent::ToolOutput { .. } => false,
     }
 }