@gajae-code/coding-agent 0.4.5 → 0.5.1

package/src/modes/components/status-line/segments.ts

@@ -66,7 +66,7 @@ function classifyProjectDir(pwd: string): { scratch: boolean; relative: string |
 const gajaeSegment: StatusLineSegment = {
 	id: "gajae",
 	render(_ctx) {
-		return { content: theme.fg("accent", "GJC"), visible: true };
+		return { content: theme.fg("accent", "🦞"), visible: true };
 	},
 };
 

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

@@ -152,6 +152,7 @@ export class ToolExecutionComponent extends Container {
 		isError?: boolean;
 		details?: any;
 	};
+	#textOutputCache?: { content: unknown; showImages: boolean; terminalImageProtocol: unknown; output: string };
 	// Edit preview state
 	#editMode?: EditMode;
 	#editDiffPreview?: PerFileDiffPreview[];
@@ -197,9 +198,11 @@ export class ToolExecutionComponent extends Container {
 
 		this.addChild(new Spacer(1));
 
-		// Always create both - contentBox for custom tools/bash/tools with renderers, contentText for other built-ins
-		this.#contentBox = new Box(1, 1, (text: string) => theme.bg("toolPendingBg", text));
-		this.#contentText = new Text("", 1, 1, (text: string) => theme.bg("toolPendingBg", text));
+		// Always create both - contentBox for custom tools/bash/tools with renderers, contentText for other built-ins.
+		// Vertical padding is 0: block separation comes solely from the leading Spacer
+		// (1 blank line above each block), matching reference TUIs (083.2).
+		this.#contentBox = new Box(1, 0, (text: string) => theme.bg("toolPendingBg", text));
+		this.#contentText = new Text("", 1, 0, (text: string) => theme.bg("toolPendingBg", text));
 
 		// Use Box for custom tools or built-in tools that have renderers
 		const hasRenderer = toolName in toolRenderers;
@@ -295,6 +298,7 @@ export class ToolExecutionComponent extends Container {
 		isPartial = false,
 		_toolCallId?: string,
 	): void {
+		this.#textOutputCache = undefined;
 		this.#result = result;
 		this.#isPartial = isPartial;
 		// When tool is complete, ensure args are marked complete so spinner stops
@@ -397,6 +401,7 @@ export class ToolExecutionComponent extends Container {
 
 	setShowImages(show: boolean): void {
 		this.#showImages = show;
+		this.#textOutputCache = undefined;
 		this.#updateDisplay();
 	}
 
@@ -514,7 +519,7 @@ export class ToolExecutionComponent extends Container {
 					const fileBgFn = fileResult.isError
 						? (text: string) => theme.bg("toolErrorBg", text)
 						: (text: string) => theme.bg("toolSuccessBg", text);
-					const fileBox = new Box(1, 1, fileBgFn);
+					const fileBox = new Box(1, 0, fileBgFn);
 					try {
 						const resultComponent = renderer.renderResult(
 							{ content: [], details: fileResult, isError: fileResult.isError },
@@ -540,7 +545,7 @@ export class ToolExecutionComponent extends Container {
 					const pendingSpacer = new Spacer(1);
 					this.#multiFileBoxes.push(pendingSpacer);
 					this.addChild(pendingSpacer);
-					const pendingBox = new Box(1, 1, (text: string) => theme.bg("toolPendingBg", text));
+					const pendingBox = new Box(1, 0, (text: string) => theme.bg("toolPendingBg", text));
 					const pendingText = renderStatusLine(
 						{
 							icon: "pending",
@@ -723,16 +728,27 @@ export class ToolExecutionComponent extends Container {
 	#getTextOutput(): string {
 		if (!this.#result) return "";
 
-		const textBlocks = this.#result.content?.filter((c: any) => c.type === "text") || [];
-		const imageBlocks = this.#getAllImageBlocks();
+		const content = this.#result.content;
+		const terminalImageProtocol = TERMINAL.imageProtocol;
+		const cached = this.#textOutputCache;
+		if (
+			cached?.content === content &&
+			cached.showImages === this.#showImages &&
+			cached.terminalImageProtocol === terminalImageProtocol
+		) {
+			return cached.output;
+		}
 
-		let output = textBlocks
-			.map((c: any) => {
-				return sanitizeWithOptionalSixelPassthrough(c.text || "", sanitizeText);
-			})
-			.join("\n");
+		const textParts: string[] = [];
+		for (const block of content ?? []) {
+			if (block.type !== "text") continue;
+			const text = block.text || "";
+			textParts.push(sanitizeWithOptionalSixelPassthrough(text, sanitizeText));
+		}
+		let output = textParts.join("\n");
 
-		if (imageBlocks.length > 0 && (!TERMINAL.imageProtocol || !this.#showImages)) {
+		const imageBlocks = this.#getAllImageBlocks();
+		if (imageBlocks.length > 0 && (!terminalImageProtocol || !this.#showImages)) {
 			const imageIndicators = imageBlocks
 				.map((img: any) => {
 					const dims = img.data ? (getImageDimensions(img.data, img.mimeType) ?? undefined) : undefined;
@@ -742,6 +758,7 @@ export class ToolExecutionComponent extends Container {
 			output = output ? `${output}\n${imageIndicators}` : imageIndicators;
 		}
 
+		this.#textOutputCache = { content, showImages: this.#showImages, terminalImageProtocol, output };
 		return output;
 	}
 

package/src/modes/controllers/command-controller.ts

@@ -13,6 +13,7 @@ import {
 import { Loader, Markdown, padding, Spacer, Text, visibleWidth } from "@gajae-code/tui";
 import { formatDuration, Snowflake, setProjectDir } from "@gajae-code/utils";
 import { $ } from "bun";
+import { jobElapsedMs } from "../../async";
 import { reset as resetCapabilities } from "../../capability";
 import { clearClaudePluginRootsCache } from "../../discovery/helpers";
 import { loadCustomShare } from "../../export/custom-share";
@@ -1279,7 +1280,7 @@ const BAR_WIDTH_MAX = 24;
 const BAR_WIDTH_MIN = 4;
 
 function renderJobLine(job: AsyncJobSnapshotItem, now: number): string {
-	const duration = formatDuration(Math.max(0, now - job.startTime));
+	const duration = formatDuration(jobElapsedMs(job, now));
 	const status = formatJobStatus(job.status);
 	return `${theme.fg("dim", job.id)} ${theme.fg("dim", `[${job.type}]`)} ${status} ${theme.fg("dim", `(${duration})`)}`;
 }
@@ -1538,7 +1539,7 @@ function resolveColumnWidth(count: number, available: number, trailing: number):
 	return ideal;
 }
 
-function renderUsageReports(
+export function renderUsageReports(
 	reports: UsageReport[],
 	uiTheme: typeof theme,
 	nowMs: number,
@@ -1592,17 +1593,35 @@ function renderUsageReports(
 
 		lines.push(uiTheme.bold(uiTheme.fg("accent", providerName)));
 
+		// Stable account column order shared across every window group, so each
+		// account keeps the same column in the 5h / 7d / ... rows. Rank accounts
+		// by total usage across their windows (a per-account value identical for
+		// every group), tie-broken by label for determinism.
+		const rankedAccounts = providerReports
+			.map(report => {
+				const [firstLimit] = report.limits;
+				return {
+					report,
+					total: report.limits.reduce((sum, limit) => sum + (resolveFraction(limit) ?? 0), 0),
+					label: firstLimit ? formatAccountLabel(firstLimit, report, 0) : formatUnlimitedReportLabel(report, 0),
+				};
+			})
+			.sort((a, b) => (a.total !== b.total ? b.total - a.total : a.label.localeCompare(b.label)));
+		const accountRank = new Map<UsageReport, number>();
+		rankedAccounts.forEach((entry, rank) => {
+			accountRank.set(entry.report, rank);
+		});
+
 		const renderableGroups = Array.from(limitGroups.values()).map(group => {
 			const entries = group.limits.map((limit, index) => ({
 				limit,
 				report: group.reports[index],
-				fraction: resolveFraction(limit),
 				index,
 			}));
 			entries.sort((a, b) => {
-				const aFraction = a.fraction ?? -1;
-				const bFraction = b.fraction ?? -1;
-				if (aFraction !== bFraction) return bFraction - aFraction;
+				const aRank = accountRank.get(a.report) ?? Number.MAX_SAFE_INTEGER;
+				const bRank = accountRank.get(b.report) ?? Number.MAX_SAFE_INTEGER;
+				if (aRank !== bRank) return aRank - bRank;
 				return a.index - b.index;
 			});
 			const sortedLimits = entries.map(entry => entry.limit);

package/src/modes/controllers/extension-ui-controller.ts

@@ -645,6 +645,9 @@ export class ExtensionUiController {
 				timeout: dialogOptions?.timeout,
 				onTimeout: dialogOptions?.onTimeout,
 				tui: this.ctx.ui,
+				// Share the main prompt editor's autocomplete provider so the
+				// inline "Other (type your own)" editor supports `@` file links.
+				autocompleteProvider: dialogOptions?.customInput ? this.ctx.editor.getAutocompleteProvider() : undefined,
 				outline: dialogOptions?.outline,
 				wrapFocused: dialogOptions?.wrapFocused,
 				scrollTitleRows,

package/src/modes/controllers/selector-controller.ts

@@ -5,6 +5,7 @@ import type { Component, OverlayHandle } from "@gajae-code/tui";
 import { Input, Loader, Spacer, Text } from "@gajae-code/tui";
 import { getAgentDbPath, getProjectDir } from "@gajae-code/utils";
 import { activateModelProfile } from "../../config/model-profile-activation";
+import { recommendModelProfileForProvider } from "../../config/model-profiles";
 import { settings } from "../../config/settings";
 import { DebugSelectorComponent } from "../../debug";
 import { disableProvider, enableProvider } from "../../discovery";
@@ -45,7 +46,7 @@ import { CustomProviderWizardComponent, type CustomProviderWizardSubmit } from "
 import { ExtensionDashboard } from "../components/extensions";
 import { HistorySearchComponent } from "../components/history-search";
 import { JobsOverlayComponent } from "../components/jobs-overlay";
-import { ModelSelectorComponent, type ModelSelectorSelection } from "../components/model-selector";
+import { ModelSelectorComponent } from "../components/model-selector";
 import { OAuthSelectorComponent } from "../components/oauth-selector";
 import { PluginSelectorComponent } from "../components/plugin-selector";
 import {
@@ -69,6 +70,7 @@ const CALLBACK_SERVER_PROVIDERS = new Set<string>([
 	"google-gemini-cli",
 	"google-antigravity",
 	"xai",
+	"grok-build",
 ]);
 
 const MANUAL_LOGIN_TIP = "Tip: You can complete pairing with /login <redirect URL>.";
@@ -537,12 +539,6 @@ export class SelectorController {
 				this.ctx.session.scopedModels,
 				async selection => {
 					try {
-						if (selection.kind === "preset") {
-							await this.#applyModelAssignmentPreset(selection);
-							done();
-							this.ctx.ui.requestRender();
-							return;
-						}
 						if (selection.kind === "profile") {
 							await activateModelProfile(
 								{
@@ -609,45 +605,12 @@ export class SelectorController {
 					done();
 					this.ctx.ui.requestRender();
 				},
-				options,
+				{ ...options, sessionId: this.ctx.session.sessionId },
 			);
 			return { component: selector, focus: selector };
 		});
 	}
 
-	async #applyModelAssignmentPreset(selection: Extract<ModelSelectorSelection, { kind: "preset" }>): Promise<void> {
-		const { assignments, model, preset, selector } = selection;
-		const apiKey = await this.ctx.session.modelRegistry.getApiKey(model, this.ctx.session.sessionId);
-		if (!apiKey) {
-			throw new Error(`No API key for ${model.provider}/${model.id}`);
-		}
-
-		const defaultThinkingLevel = assignments.default;
-		await this.ctx.session.setModel(model, "default", {
-			selector,
-			thinkingLevel: defaultThinkingLevel,
-		});
-		if (defaultThinkingLevel && defaultThinkingLevel !== ThinkingLevel.Inherit) {
-			this.ctx.session.setThinkingLevel(defaultThinkingLevel);
-		}
-
-		const overrides = this.ctx.settings.get("task.agentModelOverrides");
-		const nextOverrides = { ...overrides };
-		for (const [targetRole, presetThinkingLevel] of Object.entries(assignments) as [
-			keyof Extract<ModelSelectorSelection, { kind: "preset" }>["assignments"],
-			ThinkingLevel,
-		][]) {
-			if (!targetRole || targetRole === "default") continue;
-			nextOverrides[targetRole] =
-				presetThinkingLevel === ThinkingLevel.Inherit ? selector : `${selector}:${presetThinkingLevel}`;
-		}
-		this.ctx.settings.set("task.agentModelOverrides", nextOverrides);
-		this.ctx.settings.getStorage()?.recordModelUsage(`${model.provider}/${model.id}`);
-		this.ctx.statusLine.invalidate();
-		this.ctx.updateEditorBorderColor();
-		this.ctx.showStatus(`${preset.label}: ${selector}`);
-	}
-
 	async showPluginSelector(mode: "install" | "uninstall" = "install"): Promise<void> {
 		const mgr = new MarketplaceManager({
 			marketplacesRegistryPath: getMarketplacesRegistryPath(),
@@ -1034,6 +997,34 @@ export class SelectorController {
 		await this.showSessionSelector();
 	}
 
+	async #handlePostLoginModelProfileRecommendation(providerId: string): Promise<void> {
+		const recommendedProfile = recommendModelProfileForProvider(
+			providerId,
+			this.ctx.session.modelRegistry.getModelProfiles(),
+		);
+		if (!recommendedProfile) {
+			return;
+		}
+
+		const activeProfile = this.ctx.session.getActiveModelProfile?.() ?? this.ctx.settings.get("modelProfile.default");
+		if (activeProfile) {
+			this.ctx.showStatus(`Preset ${recommendedProfile.name} is available in /model.`);
+			return;
+		}
+
+		const confirmed = await this.ctx.showHookConfirm(`Apply ${recommendedProfile.name} now?`, "");
+		if (!confirmed) {
+			return;
+		}
+
+		await activateModelProfile({
+			session: this.ctx.session,
+			modelRegistry: this.ctx.session.modelRegistry,
+			settings: this.ctx.settings,
+			profileName: recommendedProfile.name,
+		});
+	}
+
 	async #handleOAuthLogin(providerId: string): Promise<void> {
 		this.ctx.showStatus(`Logging in to ${providerId}…`);
 		const manualInput = this.ctx.oauthManualInput;
@@ -1090,6 +1081,7 @@ export class SelectorController {
 				new Text(theme.fg("success", `${theme.status.success} Successfully logged in to ${providerId}`), 1, 0),
 			);
 			this.ctx.chatContainer.addChild(new Text(theme.fg("dim", `Credentials saved to ${getAgentDbPath()}`), 1, 0));
+			await this.#handlePostLoginModelProfileRecommendation(providerId);
 			this.ctx.ui.requestRender();
 		} catch (error: unknown) {
 			this.ctx.showError(`Login failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -1120,7 +1112,7 @@ export class SelectorController {
 	async showOAuthSelector(mode: "login" | "logout", providerId?: string): Promise<void> {
 		if (providerId) {
 			const oauthProvider = getOAuthProviders().find(provider => provider.id === providerId);
-			if (!oauthProvider) {
+			if (!oauthProvider && !this.ctx.session.modelRegistry.getModelProfiles().has(providerId)) {
 				this.ctx.showError(`Unknown OAuth provider: ${providerId}`);
 				return;
 			}

package/src/modes/rpc/rpc-client.ts

@@ -12,6 +12,7 @@ import type { SessionStats } from "../../session/agent-session";
 import type {
 	RpcCommand,
 	RpcExtensionUIRequest,
+	RpcGetStateInclude,
 	RpcHandoffResult,
 	RpcHostToolCallRequest,
 	RpcHostToolCancelRequest,
@@ -442,8 +443,8 @@ export class RpcClient {
 	/**
 	 * Get current session state.
 	 */
-	async getState(): Promise<RpcSessionState> {
-		const response = await this.#send({ type: "get_state" });
+	async getState(include?: RpcGetStateInclude[]): Promise<RpcSessionState> {
+		const response = await this.#send(include ? { type: "get_state", include } : { type: "get_state" });
 		return this.#getData(response);
 	}
 

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

@@ -10,8 +10,10 @@
  * - Events: AgentSessionEvent objects streamed as they occur
  * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
  */
+
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { $env, readJsonl, Snowflake } from "@gajae-code/utils";
+import { $pickenv, readLines, Snowflake } from "@gajae-code/utils";
 import type {
 	ExtensionUIContext,
 	ExtensionUIDialogOptions,
@@ -23,6 +25,7 @@ import { initializeExtensions } from "../runtime-init";
 import { dispatchRpcCommand } from "../shared/agent-wire/command-dispatch";
 import { AgentWireFrameSequencer, toAgentWireEventFrame } from "../shared/agent-wire/event-envelope";
 import { rpcError as error } from "../shared/agent-wire/responses";
+import { registerRpcSession, unregisterRpcSession } from "../shared/agent-wire/session-registry";
 import { defaultAuditPath, UnattendedAuditLog } from "../shared/agent-wire/unattended-audit";
 import { UnattendedSessionControlPlane } from "../shared/agent-wire/unattended-session";
 import { FileGateStore } from "../shared/agent-wire/workflow-gate-broker";
@@ -70,13 +73,15 @@ function parseValueDialogResponse(
 	return undefined;
 }
 
-function shouldEmitRpcTitles(): boolean {
-	const raw = $env.PI_RPC_EMIT_TITLE;
+export function shouldEmitRpcTitlesForTest(): boolean {
+	const raw = $pickenv("GJC_RPC_EMIT_TITLE", "PI_RPC_EMIT_TITLE");
 	if (!raw) return false;
 	const normalized = raw.trim().toLowerCase();
 	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
 }
 
+const shouldEmitRpcTitles = shouldEmitRpcTitlesForTest;
+
 function auditOutcomeFor(event: string): "accepted" | "rejected" | "denied" | "exceeded" | "aborted" | "info" {
 	if (event.includes("denied")) return "denied";
 	if (event.includes("exceeded")) return "exceeded";
@@ -156,6 +161,7 @@ export function requestRpcEditor(
 export async function runRpcMode(
 	session: AgentSession,
 	setToolUIContext?: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
+	options?: { listen?: string },
 ): Promise<never> {
 	// Signal to RPC clients that the server is ready to accept commands
 	// Suppress terminal notifications: they write \x07 (BEL) or OSC sequences directly to
@@ -164,11 +170,20 @@ export async function runRpcMode(
 	// may write there.
 	process.env.PI_NOTIFICATIONS = "off";
 
-	process.stdout.write(`${JSON.stringify({ type: "ready" })}\n`);
+	// Frames go to a swappable sink: stdout for stdio, the active client socket for a
+	// persistent --listen (UDS) server. Defaults to stdout, so the stdio path is unchanged.
+	let frameSink = (line: string): void => {
+		process.stdout.write(line);
+	};
 	const output = (obj: RpcResponse | RpcExtensionUIRequest | object) => {
-		process.stdout.write(`${JSON.stringify(obj)}\n`);
+		frameSink(`${JSON.stringify(obj)}\n`);
 	};
+	// stdio announces readiness immediately; the UDS server announces it per client connection.
+	if (!options?.listen) {
+		output({ type: "ready" });
+	}
 	const emitRpcTitles = shouldEmitRpcTitles();
+	const decodeError = (err: unknown): string => (err instanceof Error ? err.message : String(err));
 
 	const pendingExtensionRequests = new Map<string, PendingExtensionRequest>();
 	const hostToolBridge = new RpcHostToolBridge(output);
@@ -229,6 +244,37 @@ export async function runRpcMode(
 
 	// Shutdown request flag (wrapped in object to allow mutation with const)
 	const shutdownState = { requested: false };
+	let shutdownStarted = false;
+	// Tracks in-flight non-blocking command handlers so shutdown can drain them.
+	const inFlightCommands = new Set<Promise<void>>();
+	async function shutdown(exitCode: number, reason: string): Promise<never> {
+		if (shutdownStarted) {
+			process.exit(exitCode);
+		}
+		shutdownStarted = true;
+		// Let in-flight non-blocking commands (bash/compact/handoff) finish and emit
+		// their responses before teardown, bounded so a never-resolving login cannot
+		// wedge shutdown (issue 13).
+		if (inFlightCommands.size > 0) {
+			await Promise.race([Promise.allSettled([...inFlightCommands]), Bun.sleep(5000)]);
+		}
+		await unregisterRpcSession(session.sessionId).catch(() => {});
+		hostToolBridge.rejectAllPending(`${reason} before host tool execution completed`);
+		hostUriBridge.clear(`${reason} before host URI request completed`);
+		try {
+			await session.sessionManager.ensureOnDisk();
+		} catch (err) {
+			output(error(undefined, "shutdown", decodeError(err)));
+			process.exit(1);
+		}
+		try {
+			await session.dispose();
+		} catch (err) {
+			output(error(undefined, "shutdown", decodeError(err)));
+			process.exit(1);
+		}
+		process.exit(exitCode);
+	}
 
 	/**
 	 * Extension UI context that uses the RPC protocol.
@@ -376,7 +422,7 @@ export async function runRpcMode(
 		}
 
 		setTitle(title: string): void {
-			// Title updates are low-value noise for most RPC hosts; opt in via PI_RPC_EMIT_TITLE=1.
+			// Title updates are low-value noise for most RPC hosts; opt in via GJC_RPC_EMIT_TITLE=1.
 			if (!emitRpcTitles) return;
 			this.output({
 				type: "extension_ui_request",
@@ -491,62 +537,164 @@ export async function runRpcMode(
 			unattendedControlPlane,
 		});
 
+	// Cancellation commands must interrupt in-flight work, so they bypass the ordered
+	// queue and run immediately. Everything else runs through a serial chain so causal
+	// order is preserved (e.g. `get_state` after `bash` still observes the bash result)
+	// while the read loop itself never blocks — that is what lets a cancellation command
+	// reach a long-running `bash`/`compact`/`handoff`/`login` instead of being
+	// head-of-line-blocked behind it (issue 13).
+	const CANCELLATION_COMMANDS = new Set<RpcCommand["type"]>(["abort", "abort_bash", "abort_retry"]);
+	let orderedChain: Promise<void> = Promise.resolve();
+	const runCommand = async (command: RpcCommand): Promise<void> => {
+		try {
+			output(await handleCommand(command));
+		} catch (err) {
+			output(error(command.id, command.type, decodeError(err)));
+		}
+	};
+	const trackCommand = (task: Promise<void>): void => {
+		inFlightCommands.add(task);
+		void task.finally(() => inFlightCommands.delete(task));
+	};
+	const dispatchCommand = (command: RpcCommand): void => {
+		if (CANCELLATION_COMMANDS.has(command.type)) {
+			trackCommand(runCommand(command));
+			return;
+		}
+		orderedChain = orderedChain.then(() => runCommand(command));
+		trackCommand(orderedChain);
+	};
+
 	/**
 	 * Check if shutdown was requested and perform shutdown if so.
 	 * Called after handling each command when waiting for the next command.
 	 */
 	async function checkShutdownRequested(): Promise<void> {
 		if (!shutdownState.requested) return;
-
-		if (session.extensionRunner?.hasHandlers("session_shutdown")) {
-			await session.extensionRunner.emit({ type: "session_shutdown" });
-		}
-
-		process.exit(0);
+		await shutdown(0, "RPC shutdown requested");
 	}
 
-	// Listen for JSON input using Bun's stdin
-	for await (const parsed of readJsonl(Bun.stdin.stream())) {
+	// Parse + route a single inbound JSONL frame. Shared by the stdio reader and the
+	// persistent UDS server so both transports use the same command surface.
+	const inputDecoder = new TextDecoder("utf-8", { fatal: false });
+	async function handleInboundLine(text: string): Promise<void> {
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(text);
+		} catch (err) {
+			output(error(undefined, "parse", `Failed to parse command: ${decodeError(err)}`));
+			return;
+		}
 		try {
-			// Handle extension UI responses
 			if ((parsed as RpcExtensionUIResponse).type === "extension_ui_response") {
 				const response = parsed as RpcExtensionUIResponse;
-				const pending = pendingExtensionRequests.get(response.id);
-				if (pending) {
-					pending.resolve(response);
-				}
-				continue;
+				pendingExtensionRequests.get(response.id)?.resolve(response);
+				return;
 			}
-
 			if (isRpcHostToolResult(parsed)) {
 				hostToolBridge.handleResult(parsed);
-				continue;
+				return;
 			}
-
 			if (isRpcHostToolUpdate(parsed)) {
 				hostToolBridge.handleUpdate(parsed);
-				continue;
+				return;
 			}
-
 			if (isRpcHostUriResult(parsed)) {
 				hostUriBridge.handleResult(parsed);
-				continue;
+				return;
 			}
-
-			// Handle regular commands
-			const command = parsed as RpcCommand;
-			const response = await handleCommand(command);
-			output(response);
-
-			// Check for deferred shutdown request (idle between commands)
+			// Ordered commands run through a serial chain to preserve causal order; the
+			// reader never blocks, so cancellation commands stay responsive even while a
+			// long command is in flight (issue 13).
+			dispatchCommand(parsed as RpcCommand);
 			await checkShutdownRequested();
-		} catch (e: any) {
-			output(error(undefined, "parse", `Failed to parse command: ${e.message}`));
+		} catch (err) {
+			output(error(undefined, "parse", `Failed to parse command: ${decodeError(err)}`));
 		}
 	}
 
-	// stdin closed — RPC client is gone, exit cleanly
-	hostToolBridge.rejectAllPending("RPC client disconnected before host tool execution completed");
-	hostUriBridge.clear("RPC client disconnected before host URI request completed");
-	process.exit(0);
+	// Persistent UDS server (issue 09): keep the AgentSession alive across client
+	// reconnects instead of exiting on stdin EOF. Frames route to the active client
+	// socket; while no client is connected they are dropped (clients resync via
+	// get_state/get_messages on reconnect).
+	if (options?.listen) {
+		const socketPath = options.listen;
+		await fs.mkdir(path.dirname(socketPath), { recursive: true }).catch(() => {});
+		await fs.rm(socketPath, { force: true }).catch(() => {});
+		await registerRpcSession({
+			sessionId: session.sessionId,
+			pid: process.pid,
+			transport: "socket",
+			cwd: session.sessionManager.getCwd(),
+			model: session.model?.id,
+			startedAt: new Date().toISOString(),
+			endpoint: socketPath,
+		}).catch(() => {});
+
+		const noopSink = (_line: string): void => {};
+		let currentSocket: object | undefined;
+		let buf = "";
+		Bun.listen({
+			unix: socketPath,
+			socket: {
+				open(socket) {
+					currentSocket = socket;
+					buf = "";
+					frameSink = (line: string) => {
+						socket.write(line);
+					};
+					output({ type: "ready" });
+				},
+				data(socket, data) {
+					if (socket !== currentSocket) return;
+					buf += inputDecoder.decode(data);
+					while (true) {
+						const nl = buf.indexOf("\n");
+						if (nl < 0) break;
+						const text = buf.slice(0, nl).trim();
+						buf = buf.slice(nl + 1);
+						if (text) void handleInboundLine(text);
+					}
+				},
+				close(socket) {
+					if (socket === currentSocket) {
+						currentSocket = undefined;
+						frameSink = noopSink;
+					}
+				},
+				error() {},
+			},
+		});
+
+		const onSignal = (): void => {
+			void shutdown(0, "RPC socket server signal");
+		};
+		process.on("SIGINT", onSignal);
+		process.on("SIGTERM", onSignal);
+		// Block until an explicit shutdown (signal/extension) calls process.exit.
+		await new Promise<never>(() => {});
+		throw new Error("RPC socket server returned unexpectedly");
+	}
+
+	// Register this stdio RPC session so other processes can discover it (issue 10).
+	await registerRpcSession({
+		sessionId: session.sessionId,
+		pid: process.pid,
+		transport: "stdio",
+		cwd: session.sessionManager.getCwd(),
+		model: session.model?.id,
+		startedAt: new Date().toISOString(),
+	}).catch(() => {});
+
+	// Listen for JSONL input using Bun's stdin. Parse frame-by-frame so a malformed
+	// command reports a parse error without poisoning the whole long-lived RPC session.
+	for await (const line of readLines(Bun.stdin.stream())) {
+		const text = inputDecoder.decode(line).trim();
+		if (!text) continue;
+		await handleInboundLine(text);
+	}
+
+	// stdin closed — RPC client is gone, flush durable state and exit cleanly
+	await shutdown(0, "RPC client disconnected");
+	throw new Error("RPC shutdown returned unexpectedly");
 }