@oh-my-pi/pi-coding-agent 15.1.3 → 15.1.5

package/src/modes/acp/acp-agent.ts

@@ -66,7 +66,11 @@ import {
 import { ACP_BUILTIN_SLASH_COMMANDS, executeAcpBuiltinSlashCommand } from "../../slash-commands/acp-builtins";
 import { parseThinkingLevel } from "../../thinking";
 import { createAcpClientBridge } from "./acp-client-bridge";
-import { mapAgentSessionEventToAcpSessionUpdates, mapToolKind } from "./acp-event-mapper";
+import {
+	buildToolCallStartUpdate,
+	mapAgentSessionEventToAcpSessionUpdates,
+	normalizeReplayToolArguments,
+} from "./acp-event-mapper";
 import { ACP_TERMINAL_AUTH_FLAG } from "./terminal-auth";
 
 const ACP_DEFAULT_MODE_ID = "default";
@@ -87,6 +91,8 @@ const SESSION_PAGE_SIZE = 50;
  */
 export const ACP_BOOTSTRAP_RACE_GUARD_MS = 50;
 const ACP_CANCEL_CLEANUP_TIMEOUT_MS = 5_000;
+const ACP_ASYNC_DELIVERY_DRAIN_TIMEOUT_MS = 250;
+const ACP_ASYNC_DELIVERY_DRAIN_MAX_PASSES = 3;
 
 type AgentImageContent = {
 	type: "image";
@@ -134,6 +140,7 @@ type ManagedSessionRecord = {
 	promptQueue: PromptQueueState;
 	liveMessageId: string | undefined;
 	liveMessageProgress: { textEmitted: boolean; thoughtEmitted: boolean } | undefined;
+	toolArgsById: Map<string, unknown>;
 	extensionsConfigured: boolean;
 	// Installed inside `#scheduleBootstrapUpdates` (post-race-guard); released
 	// in `#disposeSessionRecord`. Lives independent of any prompt turn.
@@ -150,6 +157,14 @@ type ReplayableMessage = {
 	isError?: boolean;
 };
 
+type ReplayableToolItem = {
+	type?: unknown;
+	id?: unknown;
+	name?: unknown;
+	arguments?: unknown;
+	input?: unknown;
+};
+
 type MCPConfigMap = {
 	[name: string]: MCPServerConfig;
 };
@@ -357,7 +372,7 @@ export class AcpAgent implements Agent {
 	#clientCapabilities: ClientCapabilities | undefined;
 	#cancelCleanupTimeoutMs = ACP_CANCEL_CLEANUP_TIMEOUT_MS;
 
-	constructor(connection: AgentSideConnection, initialSession: AgentSession, createSession: CreateAcpSession) {
+	constructor(connection: AgentSideConnection, createSession: CreateAcpSession, initialSession?: AgentSession) {
 		this.#connection = connection;
 		this.#initialSession = initialSession;
 		this.#createSession = createSession;
@@ -634,7 +649,7 @@ export class AcpAgent implements Agent {
 		const builtinResult = await executeAcpBuiltinSlashCommand(text, {
 			session: record.session,
 			sessionManager: record.session.sessionManager,
-			settings: Settings.instance,
+			settings: record.session.settings,
 			cwd: record.session.sessionManager.getCwd(),
 			output: output => this.#emitCommandOutput(record, output),
 			refreshCommands: () => this.#emitAvailableCommandsUpdate(record),
@@ -806,6 +821,9 @@ export class AcpAgent implements Agent {
 			case "_omp/usage": {
 				const [firstRecord] = this.#sessions.values();
 				const target = firstRecord?.session ?? this.#initialSession;
+				if (!target) {
+					return { reports: [] };
+				}
 				const reports = await target.fetchUsageReports();
 				return { reports: reports ?? [] };
 			}
@@ -958,6 +976,7 @@ export class AcpAgent implements Agent {
 			promptQueue: { promise: Promise.resolve(), release: undefined },
 			liveMessageId: undefined,
 			liveMessageProgress: undefined,
+			toolArgsById: new Map(),
 			extensionsConfigured: false,
 			lifetimeUnsubscribe: undefined,
 		};
@@ -1020,19 +1039,27 @@ export class AcpAgent implements Agent {
 			return;
 		}
 
+		if (event.type === "tool_execution_start" || event.type === "tool_execution_update") {
+			record.toolArgsById.set(event.toolCallId, event.args);
+		}
+
 		this.#prepareLiveAssistantMessage(record, event);
 		for (const notification of mapAgentSessionEventToAcpSessionUpdates(event, record.session.sessionId, {
 			getMessageId: message => this.#getLiveMessageId(record, message),
 			getMessageProgress: message => this.#getLiveMessageProgress(record, message),
+			getToolArgs: toolCallId => record.toolArgsById.get(toolCallId),
 			cwd: record.session.sessionManager.getCwd(),
 		})) {
 			await this.#connection.sessionUpdate(notification);
 		}
+		if (event.type === "tool_execution_end") {
+			record.toolArgsById.delete(event.toolCallId);
+		}
 		this.#clearLiveAssistantMessageAfterEvent(record, event);
 
 		if (event.type === "agent_end") {
 			await this.#emitEndOfTurnUpdates(record);
-			await record.session.waitForIdle();
+			await this.#waitForAcpPromptIdle(record);
 			this.#finishPrompt(record, {
 				stopReason: this.#resolveStopReason(event, promptTurn.cancelRequested),
 				usage: this.#buildTurnUsage(promptTurn.usageBaseline, record.session.sessionManager.getUsageStatistics()),
@@ -1041,6 +1068,20 @@ export class AcpAgent implements Agent {
 		}
 	}
 
+	async #waitForAcpPromptIdle(record: ManagedSessionRecord): Promise<void> {
+		for (let pass = 0; pass < ACP_ASYNC_DELIVERY_DRAIN_MAX_PASSES; pass++) {
+			await record.session.waitForIdle();
+			const delivered = await record.session.drainAsyncJobDeliveriesForAcp({
+				timeoutMs: ACP_ASYNC_DELIVERY_DRAIN_TIMEOUT_MS,
+			});
+			if (!delivered) {
+				return;
+			}
+		}
+
+		await record.session.waitForIdle();
+	}
+
 	#prepareLiveAssistantMessage(record: ManagedSessionRecord, event: AgentSessionEvent): void {
 		if (
 			(event.type === "message_start" || event.type === "message_update" || event.type === "message_end") &&
@@ -1297,7 +1338,7 @@ export class AcpAgent implements Agent {
 
 	#getAvailableModes(session: AgentSession): Array<{ id: string; name: string; description: string }> {
 		const modes = [{ id: ACP_DEFAULT_MODE_ID, name: "Default", description: "Standard ACP headless mode" }];
-		if (Settings.instance.get("plan.enabled")) {
+		if (session.settings.get("plan.enabled")) {
 			modes.push({
 				id: ACP_PLAN_MODE_ID,
 				name: "Plan",
@@ -1581,16 +1622,30 @@ export class AcpAgent implements Agent {
 
 	async #replaySessionHistory(record: ManagedSessionRecord): Promise<void> {
 		const cwd = record.session.sessionManager.getCwd();
+		const replayedToolCallIds = new Set<string>();
+		const replayedToolCallArgs = new Map<string, unknown>();
 		for (const message of record.session.sessionManager.buildSessionContext().messages as ReplayableMessage[]) {
-			for (const notification of this.#messageToReplayNotifications(record.session.sessionId, message, cwd)) {
+			for (const notification of this.#messageToReplayNotifications(
+				record.session.sessionId,
+				message,
+				cwd,
+				replayedToolCallIds,
+				replayedToolCallArgs,
+			)) {
 				await this.#connection.sessionUpdate(notification);
 			}
 		}
 	}
 
-	#messageToReplayNotifications(sessionId: string, message: ReplayableMessage, cwd: string): SessionNotification[] {
+	#messageToReplayNotifications(
+		sessionId: string,
+		message: ReplayableMessage,
+		cwd: string,
+		replayedToolCallIds: Set<string>,
+		replayedToolCallArgs: Map<string, unknown>,
+	): SessionNotification[] {
 		if (message.role === "assistant") {
-			return this.#replayAssistantMessage(sessionId, message);
+			return this.#replayAssistantMessage(sessionId, message, cwd, replayedToolCallIds, replayedToolCallArgs);
 		}
 		if (
 			message.role === "user" ||
@@ -1610,11 +1665,19 @@ export class AcpAgent implements Agent {
 			typeof message.toolCallId === "string" &&
 			typeof message.toolName === "string"
 		) {
-			return this.#replayToolResult(sessionId, cwd, {
-				...message,
-				toolCallId: message.toolCallId,
-				toolName: message.toolName,
-			});
+			return this.#replayToolResult(
+				sessionId,
+				cwd,
+				{
+					...message,
+					toolCallId: message.toolCallId,
+					toolName: message.toolName,
+				},
+				{
+					includeStart: !replayedToolCallIds.has(message.toolCallId),
+					toolArgs: replayedToolCallArgs.get(message.toolCallId),
+				},
+			);
 		}
 		if (
 			message.role === "bashExecution" ||
@@ -1631,7 +1694,13 @@ export class AcpAgent implements Agent {
 		return [];
 	}
 
-	#replayAssistantMessage(sessionId: string, message: ReplayableMessage): SessionNotification[] {
+	#replayAssistantMessage(
+		sessionId: string,
+		message: ReplayableMessage,
+		cwd: string,
+		replayedToolCallIds: Set<string>,
+		replayedToolCallArgs: Map<string, unknown>,
+	): SessionNotification[] {
 		const notifications: SessionNotification[] = [];
 		const messageId = crypto.randomUUID();
 		if (Array.isArray(message.content)) {
@@ -1666,24 +1735,23 @@ export class AcpAgent implements Agent {
 					});
 					continue;
 				}
+				const toolItem = item as ReplayableToolItem;
 				if (
-					(item.type === "toolCall" || item.type === "tool_use") &&
-					"id" in item &&
-					typeof item.id === "string" &&
-					"name" in item &&
-					typeof item.name === "string"
+					(toolItem.type === "toolCall" || toolItem.type === "tool_use") &&
+					typeof toolItem.id === "string" &&
+					typeof toolItem.name === "string"
 				) {
-					const update: SessionUpdate = {
-						sessionUpdate: "tool_call",
-						toolCallId: item.id,
-						title: item.name,
-						kind: mapToolKind(item.name),
+					const args = this.#buildReplayAssistantToolArgs(toolItem);
+					const update = buildToolCallStartUpdate({
+						toolCallId: toolItem.id,
+						toolName: toolItem.name,
+						args,
 						status: "completed",
-					};
-					if ("arguments" in item && typeof item.arguments === "string") {
-						update.rawInput = item.arguments;
-					}
+						cwd,
+					});
 					notifications.push({ sessionId, update });
+					replayedToolCallIds.add(toolItem.id);
+					replayedToolCallArgs.set(toolItem.id, args);
 				}
 			}
 		}
@@ -1700,10 +1768,21 @@ export class AcpAgent implements Agent {
 		return notifications;
 	}
 
+	#buildReplayAssistantToolArgs(item: ReplayableToolItem): unknown {
+		if ("arguments" in item) {
+			return normalizeReplayToolArguments(item.arguments).args;
+		}
+		if (item.type === "tool_use" && "input" in item) {
+			return item.input;
+		}
+		return {};
+	}
+
 	#replayToolResult(
 		sessionId: string,
 		cwd: string,
 		message: Required<Pick<ReplayableMessage, "toolCallId" | "toolName">> & ReplayableMessage,
+		options: { includeStart?: boolean; toolArgs?: unknown } = {},
 	): SessionNotification[] {
 		const args = this.#buildReplayToolArgs(message.details);
 		const startEvent: AgentSessionEvent = {
@@ -1723,10 +1802,14 @@ export class AcpAgent implements Agent {
 				errorMessage: message.errorMessage,
 			},
 		};
-		return [
-			...mapAgentSessionEventToAcpSessionUpdates(startEvent, sessionId, { cwd }),
-			...mapAgentSessionEventToAcpSessionUpdates(endEvent, sessionId, { cwd }),
-		];
+		const notifications = mapAgentSessionEventToAcpSessionUpdates(endEvent, sessionId, {
+			cwd,
+			getToolArgs: toolCallId => (toolCallId === message.toolCallId ? options.toolArgs : undefined),
+		});
+		if (options.includeStart === false) {
+			return notifications;
+		}
+		return [...mapAgentSessionEventToAcpSessionUpdates(startEvent, sessionId, { cwd }), ...notifications];
 	}
 
 	#buildReplayToolArgs(details: unknown): { path?: string } {

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

@@ -36,7 +36,7 @@ export function createAcpClientBridge(
 		requestPermission: true,
 	};
 
-	const bridge: ClientBridge = { capabilities };
+	const bridge: ClientBridge = { capabilities, deferAgentInitiatedTurns: true };
 
 	if (capabilities.readTextFile) {
 		bridge.readTextFile = async params => {
@@ -122,6 +122,7 @@ async function requestPermission(
 		toolCallId: toolCall.toolCallId,
 		title: toolCall.title,
 		...(toolCall.kind ? { kind: toolCall.kind as ToolCallUpdate["kind"] } : {}),
+		...(toolCall.status ? { status: toolCall.status as ToolCallUpdate["status"] } : {}),
 		...(toolCall.rawInput !== undefined ? { rawInput: toolCall.rawInput } : {}),
 		...(toolCall.locations ? { locations: toolCall.locations } : {}),
 	};

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

@@ -1,6 +1,7 @@
 import type {
 	SessionNotification,
 	SessionUpdate,
+	ToolCall,
 	ToolCallContent,
 	ToolCallLocation,
 	ToolKind,
@@ -17,6 +18,7 @@ interface MessageProgress {
 interface AcpEventMapperOptions {
 	getMessageId?: (message: unknown) => string | undefined;
 	getMessageProgress?: (message: unknown) => MessageProgress | undefined;
+	getToolArgs?: (toolCallId: string) => unknown;
 	/**
 	 * Session cwd. Tool call locations sent to ACP clients must be absolute
 	 * (the editor host needs them to open or focus files). When provided,
@@ -30,6 +32,10 @@ interface ContentArrayContainer {
 	content?: unknown;
 }
 
+interface DetailsContainer {
+	details?: unknown;
+}
+
 interface TypedValue {
 	type?: unknown;
 }
@@ -38,6 +44,10 @@ interface TextLikeContent extends TypedValue {
 	text?: unknown;
 }
 
+interface TerminalIdContainer {
+	terminalId?: unknown;
+}
+
 interface BinaryLikeContent extends TypedValue {
 	data?: unknown;
 	mimeType?: unknown;
@@ -118,6 +128,8 @@ export function mapToolKind(toolName: string): ToolKind {
 		case "move":
 			return "move";
 		case "bash":
+		case "shell":
+		case "exec":
 		case "eval":
 			return "execute";
 		case "search":
@@ -144,24 +156,20 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 		case "message_end":
 			return mapAssistantMessageEnd(event, sessionId, options);
 		case "tool_execution_start": {
-			const update: SessionUpdate = {
-				sessionUpdate: "tool_call",
+			const update = buildToolCallStartUpdate({
 				toolCallId: event.toolCallId,
-				title: buildToolTitle(event.toolName, event.args, event.intent),
-				kind: mapToolKind(event.toolName),
-				status: "pending",
-				rawInput: event.args,
-			};
-			const locations = extractToolLocations(event.args, options.cwd);
-			if (locations.length > 0) {
-				update.locations = locations;
-			}
+				toolName: event.toolName,
+				args: event.args,
+				intent: event.intent,
+				cwd: options.cwd,
+			});
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_update": {
-			const terminalContent = extractTerminalToolCallContent(event.partialResult);
-			const otherContent = terminalContent.length > 0 ? [] : extractToolCallContent(event.partialResult);
-			const content = [...terminalContent, ...otherContent];
+			const content = mergeToolUpdateContent(
+				buildToolStartContent(event.toolName, event.args),
+				extractToolCallContent(event.partialResult),
+			);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -178,10 +186,11 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			return [toSessionNotification(sessionId, update)];
 		}
 		case "tool_execution_end": {
-			const diffContent = extractDiffToolCallContent(event.result);
-			const terminalContent = extractTerminalToolCallContent(event.result);
-			const otherContent = extractToolCallContent(event.result);
-			const content = [...diffContent, ...terminalContent, ...otherContent];
+			const resultContent = [...extractDiffToolCallContent(event.result), ...extractToolCallContent(event.result)];
+			const content = mergeToolUpdateContent(
+				buildToolStartContent(event.toolName, getToolExecutionEndArgs(event, options)),
+				resultContent,
+			);
 			const update: SessionUpdate = {
 				sessionUpdate: "tool_call_update",
 				toolCallId: event.toolCallId,
@@ -195,7 +204,12 @@ export function mapAgentSessionEventToAcpSessionUpdates(
 			if (locations.length > 0) {
 				update.locations = locations;
 			}
-			return [toSessionNotification(sessionId, update)];
+			const notifications = [toSessionNotification(sessionId, update)];
+			const planUpdate = mapTodoWriteResultToPlanUpdate(event);
+			if (planUpdate) {
+				notifications.push(toSessionNotification(sessionId, planUpdate));
+			}
+			return notifications;
 		}
 		case "todo_reminder": {
 			const entries = event.todos.map(todo => ({
@@ -312,6 +326,144 @@ function mapTodoStatus(status: TodoStatus): "pending" | "in_progress" | "complet
 	return todoStatusMap[status];
 }
 
+function mapTodoWriteResultToPlanUpdate(
+	event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>,
+): SessionUpdate | undefined {
+	if (event.toolName !== "todo_write" || event.isError) {
+		return undefined;
+	}
+	const phases = extractTodoWritePhases(event.result);
+	if (!Array.isArray(phases)) {
+		return undefined;
+	}
+	return {
+		sessionUpdate: "plan",
+		entries: extractTodoEntries(phases).map(todo => ({
+			content: todo.content,
+			priority: "medium" as const,
+			status: mapTodoStatus(todo.status),
+		})),
+	};
+}
+
+function extractTodoWritePhases(result: unknown): unknown {
+	if (typeof result !== "object" || result === null || !("details" in result)) {
+		return undefined;
+	}
+	const details = (result as { details?: unknown }).details;
+	if (typeof details !== "object" || details === null || !("phases" in details)) {
+		return undefined;
+	}
+	return (details as { phases?: unknown }).phases;
+}
+
+function extractTodoEntries(phases: unknown[]): Array<{ content: string; status: TodoStatus }> {
+	const entries: Array<{ content: string; status: TodoStatus }> = [];
+	for (const phase of phases) {
+		if (typeof phase !== "object" || phase === null || !("tasks" in phase)) {
+			continue;
+		}
+		const tasks = (phase as { tasks?: unknown }).tasks;
+		if (!Array.isArray(tasks)) {
+			continue;
+		}
+		for (const task of tasks) {
+			if (typeof task !== "object" || task === null || !("content" in task)) {
+				continue;
+			}
+			const content = (task as { content?: unknown }).content;
+			if (typeof content !== "string" || content.length === 0) {
+				continue;
+			}
+			const status = (task as { status?: TodoStatus }).status;
+			entries.push({ content, status: isTodoStatus(status) ? status : "pending" });
+		}
+	}
+	return entries;
+}
+
+function isTodoStatus(status: unknown): status is TodoStatus {
+	return status === "pending" || status === "in_progress" || status === "completed" || status === "abandoned";
+}
+export function buildToolCallStartUpdate(input: {
+	toolCallId: string;
+	toolName: string;
+	args: unknown;
+	intent?: string;
+	cwd?: string;
+	status?: "pending" | "completed";
+}): SessionUpdate {
+	const update: ToolCall & { sessionUpdate: "tool_call" } = {
+		sessionUpdate: "tool_call",
+		toolCallId: input.toolCallId,
+		title: buildToolTitle(input.toolName, input.args, input.intent),
+		kind: mapToolKind(input.toolName),
+		status: input.status ?? "pending",
+		rawInput: input.args,
+	};
+	const content = buildToolStartContent(input.toolName, input.args);
+	if (content.length > 0) {
+		update.content = content;
+	}
+	const locations = extractToolLocations(input.args, input.cwd);
+	if (locations.length > 0) {
+		update.locations = locations;
+	}
+	return update;
+}
+
+export function normalizeReplayToolArguments(value: unknown): { args: unknown } {
+	if (typeof value !== "string") {
+		return { args: value ?? {} };
+	}
+	try {
+		const parsed: unknown = JSON.parse(value);
+		return { args: parsed };
+	} catch {
+		return { args: value };
+	}
+}
+
+function getToolExecutionEndArgs(
+	event: Extract<AgentSessionEvent, { type: "tool_execution_end" }>,
+	options: AcpEventMapperOptions,
+): unknown {
+	if ("args" in event) {
+		return (event as { args?: unknown }).args;
+	}
+	return options.getToolArgs?.(event.toolCallId);
+}
+
+function buildToolStartContent(toolName: string, args: unknown): ToolCallContent[] {
+	if (!isCommandToolName(toolName)) {
+		return [];
+	}
+	const command = extractStringProperty<CommandContainer>(args, "command");
+	return command ? [textToolCallContent(`$ ${command}`)] : [];
+}
+
+function mergeToolUpdateContent(startContent: ToolCallContent[], resultContent: ToolCallContent[]): ToolCallContent[] {
+	if (startContent.length === 0) {
+		return resultContent;
+	}
+	const merged = [...startContent];
+	for (const item of resultContent) {
+		if (
+			item.type === "content" &&
+			item.content.type === "text" &&
+			hasEquivalentTextContent(merged, item.content.text)
+		) {
+			continue;
+		}
+		merged.push(item);
+	}
+	return merged;
+}
+
+function isCommandToolName(toolName: string): boolean {
+	return toolName === "bash" || toolName === "shell" || toolName === "exec";
+}
+
 function buildToolTitle(toolName: string, args: unknown, intent: string | undefined): string {
 	const trimmedIntent = intent?.trim();
 	if (trimmedIntent) {
@@ -418,26 +570,33 @@ function buildDiffContent(entry: unknown): ToolCallContent | undefined {
 	};
 }
 
-/** 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 extractTerminalId(value: unknown): string | undefined {
+	const direct = extractStringProperty<TerminalIdContainer>(value, "terminalId");
+	if (direct) return direct;
+	if (typeof value !== "object" || value === null) return undefined;
+	const details = (value as DetailsContainer).details;
+	return extractStringProperty<TerminalIdContainer>(details, "terminalId");
+}
+
+function terminalToolCallContent(terminalId: string): ToolCallContent {
+	return { type: "terminal", terminalId };
 }
 
 function extractToolCallContent(value: unknown): ToolCallContent[] {
 	const richContent = extractStructuredToolCallContent(value);
+	const terminalId = extractTerminalId(value);
+	const content =
+		terminalId && !hasTerminalContent(richContent, terminalId)
+			? [...richContent, terminalToolCallContent(terminalId)]
+			: richContent;
 	const fallbackText = extractReadableText(value);
 	if (!fallbackText) {
-		return richContent;
+		return content;
 	}
-	if (hasEquivalentTextContent(richContent, fallbackText)) {
-		return richContent;
+	if (hasEquivalentTextContent(content, fallbackText)) {
+		return content;
 	}
-	return [...richContent, textToolCallContent(fallbackText)];
+	return [...content, textToolCallContent(fallbackText)];
 }
 
 function extractStructuredToolCallContent(value: unknown): ToolCallContent[] {
@@ -596,6 +755,10 @@ function hasEquivalentTextContent(content: ToolCallContent[], text: string): boo
 	return content.some(item => item.type === "content" && item.content.type === "text" && item.content.text === text);
 }
 
+function hasTerminalContent(content: ToolCallContent[], terminalId: string): boolean {
+	return content.some(item => item.type === "terminal" && item.terminalId === terminalId);
+}
+
 function extractReadableText(value: unknown): string | undefined {
 	if (typeof value === "string") {
 		return normalizeText(value);
@@ -625,11 +788,24 @@ function extractReadableText(value: unknown): string | undefined {
 			return normalizeText(text);
 		}
 	}
-
+	if (isTerminalOnlyDetails(value)) {
+		return undefined;
+	}
 	const serialized = safeJsonStringify(value);
 	return normalizeText(serialized);
 }
 
+function isTerminalOnlyDetails(value: unknown): boolean {
+	if (typeof value !== "object" || value === null) {
+		return false;
+	}
+	if (extractTerminalId(value) === undefined) {
+		return false;
+	}
+	const content = (value as ContentArrayContainer).content;
+	return content === undefined || (Array.isArray(content) && content.length === 0);
+}
+
 function extractAssistantMessageText(value: unknown): string {
 	if (typeof value !== "object" || value === null || !("content" in value)) {
 		return "";

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

@@ -1,15 +1,23 @@
 import * as stream from "node:stream";
-import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+import { AgentSideConnection, ndJsonStream, type Stream } from "@agentclientprotocol/sdk";
 import type { AgentSession } from "../../session/agent-session";
 import { AcpAgent } from "./acp-agent";
 
 export type AcpSessionFactory = (cwd: string) => Promise<AgentSession>;
 
-export async function runAcpMode(session: AgentSession, createSession: AcpSessionFactory): Promise<never> {
+export function createAcpConnection(
+	transport: Stream,
+	createSession: AcpSessionFactory,
+	initialSession?: AgentSession,
+): AgentSideConnection {
+	return new AgentSideConnection(conn => new AcpAgent(conn, createSession, initialSession), transport);
+}
+
+export async function runAcpMode(createSession: AcpSessionFactory, initialSession?: AgentSession): Promise<never> {
 	const input = stream.Writable.toWeb(process.stdout);
 	const output = stream.Readable.toWeb(process.stdin);
 	const transport = ndJsonStream(input, output);
-	const connection = new AgentSideConnection(conn => new AcpAgent(conn, session, createSession), transport);
+	const connection = createAcpConnection(transport, createSession, initialSession);
 	await connection.closed;
 	process.exit(0);
 }