@oh-my-pi/pi-coding-agent 14.9.9 → 15.0.1

package/src/modes/acp/acp-client-bridge.ts

@@ -0,0 +1,152 @@
+/**
+ * ACP-side `ClientBridge` implementation. Wraps `AgentSideConnection` so the
+ * `read`/`write`/`bash`/`edit` tools (and the permission gate in
+ * `AgentSession`) can route through the client when it advertises the
+ * relevant capabilities at `initialize` time.
+ */
+import type {
+	PermissionOption as AcpPermissionOption,
+	TerminalHandle as AcpTerminalHandle,
+	AgentSideConnection,
+	ClientCapabilities,
+	RequestPermissionRequest,
+	ToolCallUpdate,
+} from "@agentclientprotocol/sdk";
+import type {
+	ClientBridge,
+	ClientBridgeCapabilities,
+	ClientBridgeCreateTerminalParams,
+	ClientBridgePermissionOption,
+	ClientBridgePermissionOutcome,
+	ClientBridgePermissionToolCall,
+	ClientBridgeTerminalHandle,
+} from "../../session/client-bridge";
+
+export function createAcpClientBridge(
+	connection: AgentSideConnection,
+	sessionId: string,
+	clientCapabilities: ClientCapabilities | undefined,
+): ClientBridge {
+	const capabilities: ClientBridgeCapabilities = {
+		readTextFile: clientCapabilities?.fs?.readTextFile === true,
+		writeTextFile: clientCapabilities?.fs?.writeTextFile === true,
+		terminal: clientCapabilities?.terminal === true,
+		// Permission requests are always usable on the connection; gating is
+		// the agent's policy choice rather than a client capability.
+		requestPermission: true,
+	};
+
+	const bridge: ClientBridge = { capabilities };
+
+	if (capabilities.readTextFile) {
+		bridge.readTextFile = async params => {
+			const response = await connection.readTextFile({
+				sessionId,
+				path: params.path,
+				...(typeof params.line === "number" ? { line: params.line } : {}),
+				...(typeof params.limit === "number" ? { limit: params.limit } : {}),
+			});
+			return response.content;
+		};
+	}
+
+	if (capabilities.writeTextFile) {
+		bridge.writeTextFile = async params => {
+			await connection.writeTextFile({
+				sessionId,
+				path: params.path,
+				content: params.content,
+			});
+		};
+	}
+
+	if (capabilities.terminal) {
+		bridge.createTerminal = (params: ClientBridgeCreateTerminalParams) =>
+			createTerminalHandle(connection, sessionId, params);
+	}
+
+	bridge.requestPermission = (toolCall, options, signal) =>
+		requestPermission(connection, sessionId, toolCall, options, signal);
+
+	return bridge;
+}
+
+async function createTerminalHandle(
+	connection: AgentSideConnection,
+	sessionId: string,
+	params: ClientBridgeCreateTerminalParams,
+): Promise<ClientBridgeTerminalHandle> {
+	const handle = await connection.createTerminal({
+		sessionId,
+		command: params.command,
+		...(params.args ? { args: params.args } : {}),
+		...(params.env ? { env: params.env } : {}),
+		...(params.cwd ? { cwd: params.cwd } : {}),
+		...(typeof params.outputByteLimit === "number" ? { outputByteLimit: params.outputByteLimit } : {}),
+	});
+	return wrapTerminalHandle(handle);
+}
+
+function wrapTerminalHandle(handle: AcpTerminalHandle): ClientBridgeTerminalHandle {
+	return {
+		terminalId: handle.id,
+		async currentOutput() {
+			const out = await handle.currentOutput();
+			return {
+				output: out.output,
+				truncated: out.truncated,
+				exitStatus: out.exitStatus ?? null,
+			};
+		},
+		async waitForExit() {
+			const status = await handle.waitForExit();
+			return { exitCode: status.exitCode ?? null, signal: status.signal ?? null };
+		},
+		async kill() {
+			await handle.kill();
+		},
+		async release() {
+			await handle.release();
+		},
+	};
+}
+
+async function requestPermission(
+	connection: AgentSideConnection,
+	sessionId: string,
+	toolCall: ClientBridgePermissionToolCall,
+	options: ClientBridgePermissionOption[],
+	signal: AbortSignal | undefined,
+): Promise<ClientBridgePermissionOutcome> {
+	const update: ToolCallUpdate = {
+		toolCallId: toolCall.toolCallId,
+		title: toolCall.title,
+		...(toolCall.kind ? { kind: toolCall.kind as ToolCallUpdate["kind"] } : {}),
+		...(toolCall.rawInput !== undefined ? { rawInput: toolCall.rawInput } : {}),
+		...(toolCall.locations ? { locations: toolCall.locations } : {}),
+	};
+	const acpOptions: AcpPermissionOption[] = options.map(option => ({
+		optionId: option.optionId,
+		name: option.name,
+		kind: option.kind,
+	}));
+	const request: RequestPermissionRequest = {
+		sessionId,
+		toolCall: update,
+		options: acpOptions,
+	};
+	if (signal?.aborted) {
+		return { outcome: "cancelled" };
+	}
+	const response = await connection.requestPermission(request);
+	const outcome = response.outcome;
+	if (outcome.outcome === "cancelled") {
+		return { outcome: "cancelled" };
+	}
+	const matched = options.find(option => option.optionId === outcome.optionId);
+	return {
+		outcome: "selected",
+		optionId: outcome.optionId,
+		...(matched ? { kind: matched.kind } : {}),
+	};
+}

package/src/modes/acp/acp-event-mapper.ts

@@ -6,10 +6,24 @@ import type {
 	ToolKind,
 } from "@agentclientprotocol/sdk";
 import type { AgentSessionEvent } from "../../session/agent-session";
+import { resolveToCwd } from "../../tools/path-utils";
 import type { TodoStatus } from "../../tools/todo-write";
 
+interface MessageProgress {
+	textEmitted: boolean;
+	thoughtEmitted: boolean;
+}
+
 interface AcpEventMapperOptions {
 	getMessageId?: (message: unknown) => string | undefined;
+	getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+	/**
+	 * Session cwd. Tool call locations sent to ACP clients must be absolute
+	 * (the editor host needs them to open or focus files). When provided,
+	 * the mapper resolves raw `path`/`file`/etc. args against this cwd
+	 * before emitting `ToolCallLocation` entries.
+	 */
+	cwd?: string;
 }
 
 interface ContentArrayContainer {
@@ -127,6 +141,8 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 	switch (event.type) {
 		case "message_update":
 			return mapAssistantMessageUpdate(event, sessionId, options);
+		case "message_end":
+			return mapAssistantMessageEnd(event, sessionId, options);
 		case "tool_execution_start": {
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call",
@@ -136,14 +152,16 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 				status: "pending",
 				rawInput: event.args,
 			};
-			const locations = extractToolLocations(event.args);
+			const locations = extractToolLocations(event.args, options.cwd);
 			if (locations.length > 0) {
 				update.locations = locations;
 			}
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_update": {
-			const content = extractToolCallContent(event.partialResult);
+			const terminalContent = extractTerminalToolCallContent(event.partialResult);
+			const otherContent = terminalContent.length > 0 ? [] : extractToolCallContent(event.partialResult);
+			const content = [...terminalContent, ...otherContent];
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -153,10 +171,17 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			if (content.length > 0) {
 				update.content = content;
 			}
+			const locations = extractToolLocations(event.args, options.cwd);
+			if (locations.length > 0) {
+				update.locations = locations;
+			}
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_end": {
-			const content = extractToolCallContent(event.result);
+			const diffContent = extractDiffToolCallContent(event.result);
+			const terminalContent = extractTerminalToolCallContent(event.result);
+			const otherContent = extractToolCallContent(event.result);
+			const content = [...diffContent, ...terminalContent, ...otherContent];
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -166,6 +191,10 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			if (content.length > 0) {
 				update.content = content;
 			}
+			const locations = extractToolLocationsFromResult(event.result, options.cwd);
+			if (locations.length > 0) {
+				update.locations = locations;
+			}
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "todo_reminder": {
@@ -194,14 +223,31 @@ function mapAssistantMessageUpdate(
 
 	let sessionUpdate: "agent_message_chunk" | "agent_thought_chunk";
 	let text: string;
+	const progress = options.getMessageProgress?.(event.message);
 	switch (event.assistantMessageEvent.type) {
 		case "text_delta":
 			sessionUpdate = "agent_message_chunk";
 			text = event.assistantMessageEvent.delta;
+			if (text.length > 0 && progress) {
+				progress.textEmitted = true;
+			}
 			break;
 		case "thinking_delta":
 			sessionUpdate = "agent_thought_chunk";
 			text = event.assistantMessageEvent.delta;
+			if (text.length > 0 && progress) {
+				progress.thoughtEmitted = true;
+			}
+			break;
+		case "done":
+			if (progress?.textEmitted) {
+				return [];
+			}
+			sessionUpdate = "agent_message_chunk";
+			text = extractAssistantMessageText(event.assistantMessageEvent.message);
+			if (text.length > 0 && progress) {
+				progress.textEmitted = true;
+			}
 			break;
 		case "error":
 			sessionUpdate = "agent_message_chunk";
@@ -224,6 +270,33 @@ function mapAssistantMessageUpdate(
 	];
 }
 
+function mapAssistantMessageEnd(
+	event: Extract<AgentSessionEvent, { type: "message_end" }>,
+	sessionId: string,
+	options: AcpEventMapperOptions,
+): SessionNotification[] {
+	if (!isAssistantMessage(event.message)) {
+		return [];
+	}
+	const progress = options.getMessageProgress?.(event.message);
+	if (!progress || progress.textEmitted) {
+		return [];
+	}
+	const text = extractAssistantMessageText(event.message);
+	if (text.length === 0) {
+		return [];
+	}
+	progress.textEmitted = true;
+	const messageId = options.getMessageId?.(event.message);
+	return [
+		toSessionNotification(sessionId, {
+			sessionUpdate: "agent_message_chunk",
+			content: { type: "text", text },
+			messageId,
+		}),
+	];
+}
+
 function toSessionNotification(sessionId: string, update: SessionUpdate): SessionNotification {
 	return { sessionId, update };
 }
@@ -257,26 +330,104 @@ function buildToolTitle(toolName: string, args: unknown, intent: string | undefi
 	return toolName;
 }
 
-function extractToolLocations(args: unknown): ToolCallLocation[] {
+/**
+ * Resolve a single raw path against cwd for an ACP location. When `cwd` is
+ * omitted we pass the value through unchanged (callers without session
+ * context, e.g. some legacy entry points and tests); the ACP-side caller
+ * always supplies cwd so notifications carry absolute paths.
+ */
+function toAcpLocationPath(value: string, cwd?: string): string {
+	if (!cwd) return value;
+	try {
+		return resolveToCwd(value, cwd);
+	} catch {
+		return value;
+	}
+}
+
+function extractToolLocations(args: unknown, cwd?: string): ToolCallLocation[] {
 	const locations: ToolCallLocation[] = [];
-	const path = extractStringProperty<PathContainer>(args, "path");
-	if (path) {
+	const seen = new Set<string>();
+	const pushPath = (raw: string | undefined) => {
+		if (!raw) return;
+		const path = toAcpLocationPath(raw, cwd);
+		if (seen.has(path)) return;
+		seen.add(path);
 		locations.push({ path });
-	}
+	};
 
-	const oldPath = extractStringProperty<OldPathContainer>(args, "oldPath");
-	if (oldPath && oldPath !== path) {
-		locations.push({ path: oldPath });
-	}
+	pushPath(extractStringProperty<PathContainer>(args, "path"));
+	pushPath(extractStringProperty<OldPathContainer>(args, "oldPath"));
+	pushPath(extractStringProperty<NewPathContainer>(args, "newPath"));
 
-	const newPath = extractStringProperty<NewPathContainer>(args, "newPath");
-	if (newPath && newPath !== path && newPath !== oldPath) {
-		locations.push({ path: newPath });
-	}
+	return locations;
+}
 
+/** Pull locations from a tool result's details (e.g. EditToolDetails.perFileResults[].path). */
+function extractToolLocationsFromResult(result: unknown, cwd?: string): ToolCallLocation[] {
+	if (typeof result !== "object" || result === null) return [];
+	const details = (result as { details?: unknown }).details;
+	if (typeof details !== "object" || details === null) return [];
+	const direct = extractToolLocations(details, cwd);
+	const perFile = (details as { perFileResults?: unknown }).perFileResults;
+	if (!Array.isArray(perFile)) {
+		return direct;
+	}
+	const seen = new Set(direct.map(loc => loc.path));
+	const locations = [...direct];
+	for (const entry of perFile) {
+		const raw = extractStringProperty<PathContainer>(entry, "path");
+		if (!raw) continue;
+		const path = toAcpLocationPath(raw, cwd);
+		if (seen.has(path)) continue;
+		seen.add(path);
+		locations.push({ path });
+	}
 	return locations;
 }
 
+/** Emit a `diff` ToolCallContent for each per-file edit result that carries oldText/newText. */
+function extractDiffToolCallContent(result: unknown): ToolCallContent[] {
+	if (typeof result !== "object" || result === null) return [];
+	const details = (result as { details?: unknown }).details;
+	if (typeof details !== "object" || details === null) return [];
+	const blocks: ToolCallContent[] = [];
+	const perFile = (details as { perFileResults?: unknown }).perFileResults;
+	const entries: unknown[] = Array.isArray(perFile) ? perFile : [details];
+	for (const entry of entries) {
+		const block = buildDiffContent(entry);
+		if (block) blocks.push(block);
+	}
+	return blocks;
+}
+
+function buildDiffContent(entry: unknown): ToolCallContent | undefined {
+	if (typeof entry !== "object" || entry === null) return undefined;
+	const candidate = entry as { path?: unknown; oldText?: unknown; newText?: unknown; isError?: unknown };
+	if (candidate.isError === true) return undefined;
+	const path = typeof candidate.path === "string" && candidate.path.length > 0 ? candidate.path : undefined;
+	if (!path) return undefined;
+	const oldText = typeof candidate.oldText === "string" ? candidate.oldText : undefined;
+	const newText = typeof candidate.newText === "string" ? candidate.newText : undefined;
+	if (oldText === undefined && newText === undefined) return undefined;
+	return {
+		type: "diff",
+		path,
+		oldText: oldText ?? null,
+		newText: newText ?? "",
+	};
+}
+
+/** Emit a `terminal` ToolCallContent when a tool result carries a `details.terminalId` (e.g. bash routed through ACP terminal/*). */
+function extractTerminalToolCallContent(result: unknown): ToolCallContent[] {
+	if (typeof result !== "object" || result === null) return [];
+	const details = (result as { details?: unknown }).details;
+	if (typeof details !== "object" || details === null) return [];
+	const terminalId = (details as { terminalId?: unknown }).terminalId;
+	if (typeof terminalId !== "string" || terminalId.length === 0) return [];
+	return [{ type: "terminal", terminalId }];
+}
+
 function extractToolCallContent(value: unknown): ToolCallContent[] {
 	const richContent = extractStructuredToolCallContent(value);
 	const fallbackText = extractReadableText(value);
@@ -479,6 +630,20 @@ function extractReadableText(value: unknown): string | undefined {
 	return normalizeText(serialized);
 }
 
+function extractAssistantMessageText(value: unknown): string {
+	if (typeof value !== "object" || value === null || !("content" in value)) {
+		return "";
+	}
+	const content = (value as ContentArrayContainer).content;
+	if (!Array.isArray(content)) {
+		return "";
+	}
+	return content
+		.map(block => extractStructuredText(block))
+		.filter((chunk): chunk is string => typeof chunk === "string" && chunk.length > 0)
+		.join("\n");
+}
+
 function extractStructuredText(value: unknown): string | undefined {
 	const text = extractStringProperty<TextLikeContent>(value, "text");
 	if (!text) {

package/src/modes/acp/terminal-auth.ts

@@ -0,0 +1,37 @@
+export const ACP_TERMINAL_AUTH_FLAG = "--acp-terminal-auth";
+
+export interface AcpTerminalAuthArgs {
+	args: string[];
+	terminalAuth: boolean;
+}
+
+export function prepareAcpTerminalAuthArgs(rawArgs: readonly string[]): AcpTerminalAuthArgs {
+	const withoutAuthFlag: string[] = [];
+	let terminalAuth = false;
+	for (const arg of rawArgs) {
+		if (arg === ACP_TERMINAL_AUTH_FLAG) {
+			terminalAuth = true;
+			continue;
+		}
+		withoutAuthFlag.push(arg);
+	}
+
+	if (!terminalAuth) {
+		return { args: withoutAuthFlag, terminalAuth: false };
+	}
+
+	const args: string[] = [];
+	for (let i = 0; i < withoutAuthFlag.length; i++) {
+		const arg = withoutAuthFlag[i];
+		if (arg === "--mode") {
+			i++;
+			continue;
+		}
+		if (arg.startsWith("--mode=")) {
+			continue;
+		}
+		args.push(arg);
+	}
+
+	return { args, terminalAuth: true };
+}

package/src/modes/components/assistant-message.ts

@@ -3,8 +3,8 @@ import { Container, Image, ImageProtocol, Markdown, Spacer, TERMINAL, Text } fro
 import { formatNumber } from "@oh-my-pi/pi-utils";
 import { settings } from "../../config/settings";
 import { getMarkdownTheme, theme } from "../../modes/theme/theme";
+import { isSilentAbort } from "../../session/messages";
 import { resolveImageOptions } from "../../tools/render-utils";
-import { convertToPng } from "../../utils/image-convert";
 
 /**
  * Component that renders a complete assistant message
@@ -76,14 +76,15 @@ export class AssistantMessageComponent extends Container {
 			const key = `${toolCallId}:${index}`;
 			if (this.#convertedKittyImages.has(key) || this.#kittyConversionsInFlight.has(key)) continue;
 			this.#kittyConversionsInFlight.add(key);
-			convertToPng(image.data, image.mimeType)
-				.then(converted => {
+			new Bun.Image(Buffer.from(image.data, "base64"))
+				.png()
+				.toBase64()
+				.then(data => {
 					this.#kittyConversionsInFlight.delete(key);
-					if (!converted) return;
 					this.#convertedKittyImages.set(key, {
 						type: "image",
-						data: converted.data,
-						mimeType: converted.mimeType,
+						data,
+						mimeType: "image/png",
 					});
 					if (this.#lastMessage) {
 						this.updateContent(this.#lastMessage);
@@ -184,7 +185,7 @@ export class AssistantMessageComponent extends Container {
 		// But only if there are no tool calls (tool execution components will show the error)
 		const hasToolCalls = message.content.some(c => c.type === "toolCall");
 		if (!hasToolCalls) {
-			if (message.stopReason === "aborted") {
+			if (message.stopReason === "aborted" && !isSilentAbort(message.errorMessage)) {
 				const abortMessage =
 					message.errorMessage && message.errorMessage !== "Request was aborted"
 						? message.errorMessage
@@ -201,7 +202,12 @@ export class AssistantMessageComponent extends Container {
 				this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${errorMsg}`), 1, 0));
 			}
 		}
-		if (message.errorMessage && message.stopReason !== "aborted" && message.stopReason !== "error") {
+		if (
+			message.errorMessage &&
+			!isSilentAbort(message.errorMessage) &&
+			message.stopReason !== "aborted" &&
+			message.stopReason !== "error"
+		) {
 			this.#contentContainer.addChild(new Spacer(1));
 			this.#contentContainer.addChild(new Text(theme.fg("error", `Error: ${message.errorMessage}`), 1, 0));
 		}

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

@@ -7,19 +7,23 @@ import {
 	Container,
 	Ellipsis,
 	ImageProtocol,
-	Loader,
-	Spacer,
+	type Loader,
 	TERMINAL,
 	Text,
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
-import { getSymbolTheme, theme } from "../../modes/theme/theme";
-import { formatTruncationMetaNotice, type TruncationMeta } from "../../tools/output-meta";
+import { theme } from "../../modes/theme/theme";
+import type { TruncationMeta } from "../../tools/output-meta";
 import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
-import { DynamicBorder } from "./dynamic-border";
-import { truncateToVisualLines } from "./visual-truncate";
+import {
+	buildExecutionFrame,
+	buildStatusFooter,
+	createCollapsedPreview,
+	type ExecutionStatus,
+	resolveExecutionStatus,
+} from "./execution-shared";
 
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
@@ -31,7 +35,7 @@ const CHUNK_THROTTLE_MS = 50;
 
 export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
-	#status: "running" | "complete" | "cancelled" | "error" = "running";
+	#status: ExecutionStatus = "running";
 	#exitCode: number | undefined = undefined;
 	#loader: Loader;
 	#truncation?: TruncationMeta;
@@ -50,34 +54,14 @@ export class BashExecutionComponent extends Container {
 
 		// Use dim border for excluded-from-context commands (!! prefix)
 		const colorKey = excludeFromContext ? "dim" : "bashMode";
-		const borderColor = (str: string) => theme.fg(colorKey, str);
-
-		// Add spacer
-		this.addChild(new Spacer(1));
-
-		// Top border
-		this.addChild(new DynamicBorder(borderColor));
-
-		// Content container (holds dynamic content between borders)
-		this.#contentContainer = new Container();
-		this.addChild(this.#contentContainer);
+		const { contentContainer, loader } = buildExecutionFrame(this, ui, colorKey);
+		this.#contentContainer = contentContainer;
+		this.#loader = loader;
 
 		// Command header
 		this.#headerText = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
 		this.#contentContainer.addChild(this.#headerText);
-
-		// Loader
-		this.#loader = new Loader(
-			ui,
-			spinner => theme.fg(colorKey, spinner),
-			text => theme.fg("muted", text),
-			`Running… (esc to cancel)`,
-			getSymbolTheme().spinnerFrames,
-		);
 		this.#contentContainer.addChild(this.#loader);
-
-		// Bottom border
-		this.addChild(new DynamicBorder(borderColor));
 	}
 
 	/**
@@ -130,11 +114,7 @@ export class BashExecutionComponent extends Container {
 		options?: { output?: string; truncation?: TruncationMeta },
 	): void {
 		this.#exitCode = exitCode;
-		this.#status = cancelled
-			? "cancelled"
-			: exitCode !== 0 && exitCode !== undefined && exitCode !== null
-				? "error"
-				: "complete";
+		this.#status = resolveExecutionStatus(exitCode, cancelled);
 		this.#truncation = options?.truncation;
 		if (options?.output !== undefined) {
 			this.#setOutput(options.output);
@@ -182,14 +162,7 @@ export class BashExecutionComponent extends Container {
 			} else {
 				// Use shared visual truncation utility, recomputed per render width
 				const styledOutput = previewLogicalLines.map(line => theme.fg("muted", line)).join("\n");
-				const previewText = `\n${styledOutput}`;
-				this.#contentContainer.addChild({
-					render: (width: number) => {
-						const { visualLines } = truncateToVisualLines(previewText, PREVIEW_LINES, width, 1);
-						return visualLines;
-					},
-					invalidate: () => {},
-				});
+				this.#contentContainer.addChild(createCollapsedPreview(`\n${styledOutput}`, PREVIEW_LINES));
 			}
 		}
 
@@ -197,26 +170,14 @@ export class BashExecutionComponent extends Container {
 		if (this.#status === "running") {
 			this.#contentContainer.addChild(this.#loader);
 		} else {
-			const statusParts: string[] = [];
-
-			// Show how many lines are hidden (collapsed preview)
-			if (hiddenLineCount > 0 && !hasSixelOutput) {
-				statusParts.push(theme.fg("dim", `… ${hiddenLineCount} more lines (ctrl+o to expand)`));
-			}
-
-			if (this.#status === "cancelled") {
-				statusParts.push(theme.fg("warning", "(cancelled)"));
-			} else if (this.#status === "error") {
-				statusParts.push(theme.fg("error", `(exit ${this.#exitCode})`));
-			}
-
-			if (this.#truncation) {
-				statusParts.push(theme.fg("warning", formatTruncationMetaNotice(this.#truncation)));
-			}
-
-			if (statusParts.length > 0) {
-				this.#contentContainer.addChild(new Text(`\n${statusParts.join("\n")}`, 1, 0));
-			}
+			const footer = buildStatusFooter({
+				status: this.#status,
+				exitCode: this.#exitCode,
+				truncation: this.#truncation,
+				hiddenLineCount,
+				suppressHiddenCount: hasSixelOutput,
+			});
+			if (footer) this.#contentContainer.addChild(footer);
 		}
 	}