acpx 0.11.2 → 0.12.0

package/dist/{output-Smw6kFL_.js → output-CjdF5rHk.js}

@@ -1,4 +1,4 @@
-import { $ as getPerfMetricsSnapshot, B as absolutePath, C as mergeSessionOptions, Ct as promptToDisplayText, D as applyLifecycleSnapshotToRecord, Dt as withInterrupt, E as applyConversation, Et as TimeoutError, F as modelStateFromConfigOptions, Ft as isRetryablePromptError, G as listSessions, H as findSession, I as splitCommandLine, It as normalizeOutputError, J as pruneSessions, K as listSessionsForAgent, N as assertRequestedModelSupported, Ot as withTimeout, Pt as formatErrorMessage, Q as formatPerfMetric, Qt as QueueProtocolError, S as advertisedModelState, T as sessionOptionsFromRecord, Tt as InterruptedError, U as findSessionByDirectoryWalk, Ut as OUTPUT_ERROR_CODES, V as findGitRepositoryRoot, W as isoNow, Wt as OUTPUT_ERROR_ORIGINS, X as writeSessionRecord, Y as resolveSessionRecord, Zt as QueueConnectionError, _ as createSessionConversation, _t as parseJsonRpcErrorMessage, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as recordSessionUpdate, bt as isPromptInput, c as setCurrentModelId, ct as normalizeRuntimeSessionId, d as setDesiredModelId, dt as sessionBaseDir, et as incrementPerfCounter, f as syncAdvertisedModelState, ft as sessionEventActivePath, g as cloneSessionConversation, gt as isAcpJsonRpcMessage, h as cloneSessionAcpxState, ht as extractSessionUpdateNotification, i as connectAndLoadSession, it as setPerfGauge, k as AcpClient, l as setDesiredConfigOption, m as applyConfigOptionsToState, mt as sessionEventSegmentPath, n as runPromptTurn, nt as recordPerfDuration, o as currentModelIdFromSetModelResponse, p as applyConfigOptionsToRecord, pt as sessionEventLockPath, q as normalizeName, r as withConnectedSession, rt as resetPerfMetrics, s as clearDesiredConfigOption, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModeId, ut as defaultSessionEventLog, v as recordClientOperation, vt as parsePromptStopReason, w as persistSessionOptions, wt as textPrompt, x as trimConversationForRuntime, y as recordPromptSubmission, zt as toAcpErrorPayload } from "./live-checkpoint-mdAaF3qJ.js";
+import { $ as getPerfMetricsSnapshot, B as absolutePath, C as mergeSessionOptions, Ct as promptToDisplayText, D as applyLifecycleSnapshotToRecord, Dt as withInterrupt, E as applyConversation, Et as TimeoutError, F as modelStateFromConfigOptions, Ft as isRetryablePromptError, G as listSessions, H as findSession, I as splitCommandLine, It as normalizeOutputError, J as pruneSessions, K as listSessionsForAgent, Lt as extractAcpError, N as assertRequestedModelSupported, Ot as withTimeout, Pt as formatErrorMessage, Q as formatPerfMetric, Qt as QueueProtocolError, S as advertisedModelState, T as sessionOptionsFromRecord, Tt as InterruptedError, U as findSessionByDirectoryWalk, Ut as OUTPUT_ERROR_CODES, V as findGitRepositoryRoot, W as isoNow, Wt as OUTPUT_ERROR_ORIGINS, X as writeSessionRecord, Y as resolveSessionRecord, Zt as QueueConnectionError, _ as createSessionConversation, _t as parseJsonRpcErrorMessage, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as recordSessionUpdate, bt as isPromptInput, c as setCurrentModelId, ct as normalizeRuntimeSessionId, d as setDesiredModelId, dt as sessionBaseDir, et as incrementPerfCounter, f as syncAdvertisedModelState, ft as sessionEventActivePath, g as cloneSessionConversation, gt as isAcpJsonRpcMessage, h as cloneSessionAcpxState, ht as extractSessionUpdateNotification, i as connectAndLoadSession, it as setPerfGauge, k as AcpClient, l as setDesiredConfigOption, m as applyConfigOptionsToState, mt as sessionEventSegmentPath, n as runPromptTurn, nt as recordPerfDuration, o as currentModelIdFromSetModelResponse, p as applyConfigOptionsToRecord, pt as sessionEventLockPath, q as normalizeName, r as withConnectedSession, rt as resetPerfMetrics, s as clearDesiredConfigOption, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModeId, ut as defaultSessionEventLog, v as recordClientOperation, vt as parsePromptStopReason, w as persistSessionOptions, wt as textPrompt, x as trimConversationForRuntime, y as recordPromptSubmission, zt as toAcpErrorPayload } from "./live-checkpoint-ClPCSdrW.js";
 import fs, { mkdtempSync, realpathSync, writeFileSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -62,7 +62,8 @@ function queueSocketPath(sessionId, homeDir = os.homedir()) {
 }
 //#endregion
 //#region src/cli/queue/lease-store.ts
-const PROCESS_EXIT_GRACE_MS = 1500;
+const PROCESS_SIGTERM_GRACE_MS = 4e3;
+const PROCESS_SIGKILL_GRACE_MS = 1500;
 const PROCESS_POLL_MS = 50;
 const QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
 function parseQueueOwnerRecord(raw) {
@@ -160,13 +161,13 @@ async function terminateProcess(pid) {
 	} catch {
 		return false;
 	}
-	if (await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS)) return true;
+	if (await waitForProcessExit(pid, PROCESS_SIGTERM_GRACE_MS)) return true;
 	try {
 		process.kill(pid, "SIGKILL");
 	} catch {
 		return false;
 	}
-	await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS);
+	await waitForProcessExit(pid, PROCESS_SIGKILL_GRACE_MS);
 	return true;
 }
 async function ensureOwnerIsUsable(sessionId, owner) {
@@ -753,6 +754,7 @@ function isValidOwnerErrorCore(message) {
 }
 //#endregion
 //#region src/cli/queue/ipc-server.ts
+const QUEUE_SOCKET_DRAIN_TIMEOUT_MS = 1e3;
 function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
 	return {
 		type: "error",
@@ -795,6 +797,9 @@ var SessionQueueOwner = class SessionQueueOwner {
 	onQueueDepthChanged;
 	pending = [];
 	waiters = [];
+	sockets = /* @__PURE__ */ new Set();
+	taskSockets = /* @__PURE__ */ new Set();
+	drainingSockets = /* @__PURE__ */ new Set();
 	closed = false;
 	constructor(server, controlHandlers, lease, options) {
 		this.server = server;
@@ -824,7 +829,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 		});
 		return ownerRef.current;
 	}
-	async close() {
+	beginShutdown() {
 		if (this.closed) return;
 		this.closed = true;
 		for (const waiter of this.waiters.splice(0)) waiter(void 0);
@@ -832,9 +837,20 @@ var SessionQueueOwner = class SessionQueueOwner {
 			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner shutting down before prompt execution", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
 			task.close();
 		}
+		for (const socket of this.sockets) if (!this.taskSockets.has(socket) && !this.drainingSockets.has(socket)) socket.destroy();
 		this.emitQueueDepth();
+	}
+	async close() {
+		this.beginShutdown();
 		await new Promise((resolve) => {
-			this.server.close(() => resolve());
+			const forceCloseTimer = setTimeout(() => {
+				for (const socket of this.sockets) socket.destroy();
+			}, QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
+			forceCloseTimer.unref();
+			this.server.close(() => {
+				clearTimeout(forceCloseTimer);
+				resolve();
+			});
 		});
 	}
 	async nextTask(timeoutMs) {
@@ -904,7 +920,16 @@ var SessionQueueOwner = class SessionQueueOwner {
 				ownerGeneration: this.ownerGeneration
 			});
 		}).finally(() => {
-			if (!options.socket.destroyed) options.socket.end();
+			this.endSocket(options.socket);
+		});
+	}
+	endSocket(socket) {
+		if (socket.destroyed || this.drainingSockets.has(socket)) return;
+		this.taskSockets.delete(socket);
+		this.drainingSockets.add(socket);
+		socket.end(() => {
+			this.drainingSockets.delete(socket);
+			socket.destroy();
 		});
 	}
 	failRequest(socket, requestId, message, detailCode) {
@@ -912,7 +937,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 			...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
 			ownerGeneration: this.ownerGeneration
 		});
-		socket.end();
+		this.endSocket(socket);
 	}
 	parseRequestLine(socket, line) {
 		let parsed;
@@ -931,6 +956,15 @@ var SessionQueueOwner = class SessionQueueOwner {
 		this.failRequest(socket, request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
 		return true;
 	}
+	rejectClosedOwner(socket, request) {
+		if (!this.closed) return false;
+		writeQueueMessage(socket, {
+			...makeQueueOwnerError(request.requestId, "Queue owner is shutting down", "QUEUE_OWNER_CLOSED", { retryable: true }),
+			ownerGeneration: this.ownerGeneration
+		});
+		this.endSocket(socket);
+		return true;
+	}
 	handleControlQueueRequest(socket, request) {
 		if (request.type === "cancel_prompt") {
 			this.handleControlRequest({
@@ -1005,6 +1039,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 		return false;
 	}
 	enqueuePromptRequest(socket, request) {
+		this.taskSockets.add(socket);
 		const task = {
 			requestId: request.requestId,
 			message: request.message,
@@ -1026,7 +1061,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 				});
 			},
 			close: () => {
-				if (!socket.destroyed) socket.end();
+				this.endSocket(socket);
 			}
 		};
 		if (!this.enqueue(task)) return;
@@ -1038,19 +1073,20 @@ var SessionQueueOwner = class SessionQueueOwner {
 		if (!request.waitForCompletion) task.close();
 	}
 	handleConnection(socket) {
+		this.sockets.add(socket);
 		socket.setEncoding("utf8");
-		if (this.closed) {
-			writeQueueMessage(socket, makeQueueOwnerError("unknown", "Queue owner is closed", "QUEUE_OWNER_CLOSED", { retryable: true }));
-			socket.end();
-			return;
-		}
+		socket.once("close", () => {
+			this.sockets.delete(socket);
+			this.taskSockets.delete(socket);
+			this.drainingSockets.delete(socket);
+		});
 		let buffer = "";
 		let handled = false;
 		const processLine = (line) => {
 			if (handled) return;
 			handled = true;
 			const request = this.parseRequestLine(socket, line);
-			if (!request || this.rejectStaleOwnerGeneration(socket, request)) return;
+			if (!request || this.rejectClosedOwner(socket, request) || this.rejectStaleOwnerGeneration(socket, request)) return;
 			if (this.handleControlQueueRequest(socket, request)) return;
 			if (request.type !== "submit_prompt") {
 				this.failRequest(socket, request.requestId, "Invalid queue request", "QUEUE_REQUEST_INVALID");
@@ -1112,7 +1148,8 @@ function makeMalformedQueueMessageError() {
 function emitQueueOwnerError(formatter, policy, sessionId, message) {
 	formatter.setContext({ sessionId });
 	const queueErrorAlreadyEmitted = policy?.queueErrorAlreadyEmitted ?? true;
-	if (message.outputAlreadyEmitted !== true || !queueErrorAlreadyEmitted) {
+	const shouldEmitInFormatter = message.outputAlreadyEmitted !== true || !queueErrorAlreadyEmitted;
+	if (shouldEmitInFormatter) {
 		formatter.onError({
 			code: message.code ?? "RUNTIME",
 			detailCode: message.detailCode,
@@ -1123,7 +1160,7 @@ function emitQueueOwnerError(formatter, policy, sessionId, message) {
 		});
 		formatter.flush();
 	}
-	return queueConnectionErrorFromOwner(message, queueErrorAlreadyEmitted);
+	return queueConnectionErrorFromOwner(message, queueErrorAlreadyEmitted || shouldEmitInFormatter);
 }
 function parseQueueOwnerResponseLine(owner, requestId, line) {
 	let parsed;
@@ -2527,6 +2564,51 @@ const DISCARD_OUTPUT_FORMATTER = {
 	onPermissionEscalation() {},
 	flush() {}
 };
+function markOutputAlreadyEmitted(error, outputAlreadyEmitted) {
+	if (!outputAlreadyEmitted || !error || typeof error !== "object") return;
+	error.outputAlreadyEmitted = true;
+}
+async function runWithOptionalInterrupt(options) {
+	if (options.handleProcessInterrupts === false) return await options.run();
+	return await withInterrupt(options.run, options.handleInterrupt);
+}
+function attachAcpErrorPayload(error, acp) {
+	if (!acp || !error || typeof error !== "object") return;
+	error.acp = acp;
+}
+function rendersAcpErrors(policy) {
+	return policy?.queueErrorAlreadyEmitted ?? true;
+}
+function normalizedErrorText(value) {
+	return value.trim().toLowerCase();
+}
+function outboundAcpErrorMatches(error, acp) {
+	const errorText = normalizedErrorText(formatErrorMessage(error));
+	const details = acp.data?.details;
+	const candidateText = normalizedErrorText(typeof details === "string" && details.trim().length > 0 ? details : acp.message);
+	return errorText === candidateText || errorText.includes(candidateText);
+}
+var AcpErrorTracker = class {
+	latestInbound;
+	outbound = [];
+	reset() {
+		this.latestInbound = void 0;
+		this.outbound.length = 0;
+	}
+	observe(output, direction, message) {
+		output.onAcpMessage(message);
+		const acp = extractAcpError(message);
+		if (!acp) return;
+		if (direction === "inbound") {
+			this.latestInbound = acp;
+			return;
+		}
+		this.outbound.push(acp);
+	}
+	match(error) {
+		return this.latestInbound ?? this.outbound.findLast((acp) => outboundAcpErrorMatches(error, acp));
+	}
+};
 function toPromptResult(stopReason, sessionId, client) {
 	return {
 		stopReason,
@@ -2636,6 +2718,11 @@ function filterRecoverableLoadFallbackOutput(messages) {
 		return true;
 	});
 }
+function filterBufferedConnectOutput(messages, loadError) {
+	if (loadError == null) return messages;
+	const filteredMessages = new Set(filterRecoverableLoadFallbackOutput(messages.map(({ message }) => message)));
+	return messages.filter(({ message }) => filteredMessages.has(message));
+}
 function emitPromptRetryNotice(params) {
 	if (params.suppressSdkConsoleErrors) return;
 	process.stderr.write(`[acpx] prompt failed (${formatErrorMessage(params.error)}), retrying in ${params.delayMs}ms (attempt ${params.attempt}/${params.maxRetries})\n`);
@@ -2687,6 +2774,7 @@ function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatt
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
 		outputFormatter,
+		errorEmissionPolicy: { queueErrorAlreadyEmitted: true },
 		timeoutMs: task.timeoutMs,
 		suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
 		verbose: options.verbose,
@@ -2695,6 +2783,7 @@ function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatt
 		onClientAvailable: options.onClientAvailable,
 		onClientClosed: options.onClientClosed,
 		onPromptActive: options.onPromptActive,
+		handleProcessInterrupts: options.handleProcessInterrupts,
 		client: options.sharedClient
 	};
 }
@@ -2739,6 +2828,7 @@ async function runQueuedTask(sessionRecordId, task, options) {
 async function runSessionPrompt(options) {
 	const stopTotalTimer = startPerfTimer("runtime.prompt.total");
 	const output = options.outputFormatter;
+	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
 	const record = await measurePerf("session.resolve_prompt_record", async () => {
 		return await resolveSessionRecord(options.sessionRecordId);
 	});
@@ -2761,7 +2851,7 @@ async function runSessionPrompt(options) {
 	let bufferingConnectOutput = true;
 	let promptTurnActive = false;
 	let promptTurnHadSideEffects = false;
-	let sawAcpMessage = false;
+	const acpErrors = new AcpErrorTracker();
 	let eventWriterClosed = false;
 	const closeEventWriter = async (checkpoint) => {
 		if (eventWriterClosed) return;
@@ -2824,16 +2914,18 @@ async function runSessionPrompt(options) {
 	});
 	client.setEventHandlers({
 		onAcpMessage: (direction, message) => {
-			sawAcpMessage = true;
 			pendingMessages.push(message);
 			options.onAcpMessage?.(direction, message);
 		},
-		onAcpOutputMessage: (_direction, message) => {
+		onAcpOutputMessage: (direction, message) => {
 			if (bufferingConnectOutput) {
-				pendingConnectOutputMessages.push(message);
+				pendingConnectOutputMessages.push({
+					direction,
+					message
+				});
 				return;
 			}
-			output.onAcpMessage(message);
+			acpErrors.observe(output, direction, message);
 		},
 		onSessionUpdate: (notification) => {
 			if (promptTurnActive) promptTurnHadSideEffects = true;
@@ -2898,8 +2990,8 @@ async function runSessionPrompt(options) {
 	};
 	const flushConnectOutput = (loadError) => {
 		bufferingConnectOutput = false;
-		const messages = loadError == null ? pendingConnectOutputMessages : filterRecoverableLoadFallbackOutput(pendingConnectOutputMessages);
-		for (const message of messages) output.onAcpMessage(message);
+		const outputMessages = filterBufferedConnectOutput(pendingConnectOutputMessages, loadError);
+		for (const { direction, message } of outputMessages) acpErrors.observe(output, direction, message);
 		pendingConnectOutputMessages.length = 0;
 	};
 	const connectForPrompt = async () => {
@@ -2946,6 +3038,7 @@ async function runSessionPrompt(options) {
 		};
 	};
 	const runPromptAttempt = async (sessionId, attempt) => {
+		acpErrors.reset();
 		const promptStartedAt = Date.now();
 		const response = await measurePerf("runtime.prompt.agent_turn", async () => {
 			return await runPromptTurn({
@@ -2973,14 +3066,19 @@ async function runSessionPrompt(options) {
 		promptTurnActive = false;
 		applyLifecycleSnapshotToRecord(record, snapshot);
 		emitPromptDisconnectNotice(snapshot, options.verbose);
-		const normalizedError = normalizeOutputError(error, { origin: "runtime" });
+		const matchedAcpError = acpErrors.match(error);
+		const normalizedError = normalizeOutputError(error, {
+			origin: "runtime",
+			acp: matchedAcpError
+		});
 		await flushPendingMessages(false).catch(() => {});
 		output.flush();
 		record.lastUsedAt = isoNow();
 		applyConversation(record, conversation);
 		record.acpx = acpxState;
 		const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
-		propagated.outputAlreadyEmitted = sawAcpMessage;
+		attachAcpErrorPayload(propagated, normalizedError.acp);
+		propagated.outputAlreadyEmitted = matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted;
 		propagated.normalizedOutputError = normalizedError;
 		throw propagated;
 	};
@@ -3006,37 +3104,48 @@ async function runSessionPrompt(options) {
 		stopTotalTimer();
 		return response;
 	};
+	const runPrompt = async () => {
+		const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
+		await applyPromptModelIfAdvertised({
+			client,
+			sessionId: activeSessionId,
+			requestedModel: sessionOptions?.model,
+			record,
+			timeoutMs: options.timeoutMs,
+			suppressWarnings: options.suppressSdkConsoleErrors
+		});
+		acpxState = cloneSessionAcpxState(record.acpx);
+		output.setContext({ sessionId: record.acpxRecordId });
+		await liveCheckpoint.checkpoint();
+		const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
+		promptTurnActive = false;
+		return {
+			...toPromptResult(response.stopReason, record.acpxRecordId, client),
+			record,
+			resumed,
+			loadError
+		};
+	};
+	const handleInterrupt = async () => {
+		await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		record.lastUsedAt = isoNow();
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		await flushPendingMessages(false).catch(() => {});
+		if (ownClient) await client.close();
+	};
 	try {
-		return await withInterrupt(async () => {
-			const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
-			await applyPromptModelIfAdvertised({
-				client,
-				sessionId: activeSessionId,
-				requestedModel: sessionOptions?.model,
-				record,
-				timeoutMs: options.timeoutMs,
-				suppressWarnings: options.suppressSdkConsoleErrors
-			});
-			acpxState = cloneSessionAcpxState(record.acpx);
-			output.setContext({ sessionId: record.acpxRecordId });
-			await liveCheckpoint.checkpoint();
-			const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
-			promptTurnActive = false;
-			return {
-				...toPromptResult(response.stopReason, record.acpxRecordId, client),
-				record,
-				resumed,
-				loadError
-			};
-		}, async () => {
-			await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
-			applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-			record.lastUsedAt = isoNow();
-			applyConversation(record, conversation);
-			record.acpx = acpxState;
-			await flushPendingMessages(false).catch(() => {});
-			if (ownClient) await client.close();
+		return await runWithOptionalInterrupt({
+			handleProcessInterrupts: options.handleProcessInterrupts,
+			run: runPrompt,
+			handleInterrupt
 		});
+	} catch (error) {
+		const matchedAcpError = acpErrors.match(error);
+		attachAcpErrorPayload(error, matchedAcpError);
+		markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+		throw error;
 	} finally {
 		if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.total", stopTotalTimer())}\n`);
 		else stopTotalTimer();
@@ -3054,8 +3163,10 @@ async function runSessionPrompt(options) {
 }
 async function runOnce(options) {
 	const output = options.outputFormatter;
+	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
 	let promptTurnActive = false;
 	let promptTurnHadSideEffects = false;
+	const acpErrors = new AcpErrorTracker();
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		cwd: absolutePath(options.cwd),
@@ -3069,7 +3180,9 @@ async function runOnce(options) {
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
 		verbose: options.verbose,
 		onAcpMessage: options.onAcpMessage,
-		onAcpOutputMessage: (_direction, message) => output.onAcpMessage(message),
+		onAcpOutputMessage: (direction, message) => {
+			acpErrors.observe(output, direction, message);
+		},
 		onSessionUpdate: (notification) => {
 			if (promptTurnActive) promptTurnHadSideEffects = true;
 			options.onSessionUpdate?.(notification);
@@ -3085,6 +3198,7 @@ async function runOnce(options) {
 		sessionOptions: options.sessionOptions
 	});
 	const runExecPromptAttempt = async (sessionId) => {
+		acpErrors.reset();
 		return await measurePerf("runtime.exec.prompt", async () => {
 			return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
 		});
@@ -3130,6 +3244,11 @@ async function runOnce(options) {
 			await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
 			await client.close();
 		});
+	} catch (error) {
+		const matchedAcpError = acpErrors.match(error);
+		attachAcpErrorPayload(error, matchedAcpError);
+		markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+		throw error;
 	} finally {
 		await client.close();
 	}
@@ -3147,6 +3266,7 @@ async function sendSessionDirect(options) {
 		authPolicy: options.authPolicy,
 		terminal: options.terminal,
 		outputFormatter: options.outputFormatter,
+		errorEmissionPolicy: options.errorEmissionPolicy,
 		onAcpMessage: options.onAcpMessage,
 		onSessionUpdate: options.onSessionUpdate,
 		onClientOperation: options.onClientOperation,
@@ -3161,6 +3281,7 @@ async function sendSessionDirect(options) {
 //#region src/cli/session/queue-owner-runtime.ts
 const QUEUE_OWNER_STARTUP_MAX_ATTEMPTS = 120;
 const QUEUE_OWNER_HEARTBEAT_INTERVAL_MS = 5e3;
+const QUEUE_OWNER_ACTIVE_TURN_CANCEL_GRACE_MS = 750;
 async function submitToRunningOwner(options, waitForCompletion) {
 	return await trySubmitToRunningOwner({
 		sessionId: options.sessionId,
@@ -3252,8 +3373,8 @@ function logQueueOwnerReady(params) {
 async function closeQueueOwnerRuntime(params) {
 	if (params.heartbeatTimer) clearInterval(params.heartbeatTimer);
 	params.turnController.beginClosing();
-	await params.owner?.close();
 	await params.sharedClient.close().catch(() => {});
+	await params.owner?.close();
 	await writeQueueOwnerLifecycleSnapshot(params.sessionId, params.sharedClient);
 	await releaseQueueOwnerLease(params.lease);
 	if (params.verbose) process.stderr.write(`[acpx] queue owner stopped for session ${params.sessionId}\n`);
@@ -3265,6 +3386,75 @@ async function writeQueueOwnerLifecycleSnapshot(sessionId, sharedClient) {
 		await writeSessionRecord(record);
 	} catch {}
 }
+async function settlesWithin(promise, timeoutMs) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(false), timeoutMs);
+	});
+	try {
+		return await Promise.race([promise.then(() => true, () => true), timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+function createQueueOwnerShutdownController(params) {
+	let requested = false;
+	let activeTurn;
+	let activeTurnShutdown;
+	let shutdownPromise;
+	const drainActiveTurn = async () => {
+		const turn = activeTurn;
+		if (!turn) return;
+		params.turnController.requestCancel().catch((error) => {
+			logDeferredCancelFailure(error, params.verbose);
+		});
+		if (!await settlesWithin(turn, QUEUE_OWNER_ACTIVE_TURN_CANCEL_GRACE_MS)) await params.sharedClient.close().catch(() => {});
+		await turn.catch(() => {});
+	};
+	const request = () => {
+		requested = true;
+		params.stopHeartbeat();
+		params.getOwner()?.beginShutdown();
+		activeTurnShutdown ??= drainActiveTurn();
+	};
+	return {
+		get requested() {
+			return requested;
+		},
+		request,
+		setActiveTurn: (turn) => {
+			activeTurn = turn;
+		},
+		clearActiveTurn: (turn) => {
+			if (activeTurn === turn) activeTurn = void 0;
+		},
+		shutdown: () => {
+			request();
+			shutdownPromise ??= (async () => {
+				await activeTurnShutdown;
+				await closeQueueOwnerRuntime({
+					lease: params.lease,
+					owner: params.getOwner(),
+					heartbeatTimer: void 0,
+					turnController: params.turnController,
+					sharedClient: params.sharedClient,
+					sessionId: params.sessionId,
+					verbose: params.verbose
+				});
+			})();
+			return shutdownPromise;
+		}
+	};
+}
+function applyRequestedShutdown(owner, shutdown) {
+	if (shutdown.requested) owner.beginShutdown();
+}
+function startQueueOwnerHeartbeat(params) {
+	if (!params.enabled) return;
+	return setInterval(() => {
+		refreshQueueOwnerLease(params.lease, { queueDepth: params.owner.queueDepth() }).catch(() => {});
+	}, QUEUE_OWNER_HEARTBEAT_INTERVAL_MS);
+}
 async function runSessionQueueOwner(options) {
 	const lease = await tryAcquireQueueOwnerLease(options.sessionId, {
 		path: options.mcpConfigPath,
@@ -3309,6 +3499,26 @@ async function runSessionQueueOwner(options) {
 			turnController.endTurn();
 		}
 	};
+	const shutdown = createQueueOwnerShutdownController({
+		lease,
+		getOwner: () => owner,
+		stopHeartbeat: () => {
+			if (heartbeatTimer) {
+				clearInterval(heartbeatTimer);
+				heartbeatTimer = void 0;
+			}
+		},
+		turnController,
+		sharedClient,
+		sessionId: options.sessionId,
+		verbose: options.verbose
+	});
+	const onSignal = () => {
+		shutdown.request();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	process.once("SIGHUP", onSignal);
 	try {
 		owner = await SessionQueueOwner.start(lease, {
 			cancelPrompt: async () => {
@@ -3331,6 +3541,7 @@ async function runSessionQueueOwner(options) {
 				refreshQueueOwnerLease(lease, { queueDepth }).catch(() => {});
 			}
 		});
+		applyRequestedShutdown(owner, shutdown);
 		logQueueOwnerReady({
 			sessionId: options.sessionId,
 			ttlMs,
@@ -3338,16 +3549,18 @@ async function runSessionQueueOwner(options) {
 			verbose: options.verbose
 		});
 		await refreshQueueOwnerLease(lease, { queueDepth: owner.queueDepth() }).catch(() => {});
-		heartbeatTimer = setInterval(() => {
-			refreshQueueOwnerLease(lease, { queueDepth: owner?.queueDepth() ?? 0 }).catch(() => {});
-		}, QUEUE_OWNER_HEARTBEAT_INTERVAL_MS);
+		heartbeatTimer = startQueueOwnerHeartbeat({
+			enabled: !shutdown.requested,
+			lease,
+			owner
+		});
 		let isFirstTask = true;
 		while (true) {
 			const pollTimeoutMs = isFirstTask ? initialTaskPollTimeoutMs : taskPollTimeoutMs;
 			const task = await owner.nextTask(pollTimeoutMs);
 			if (!task) break;
 			isFirstTask = false;
-			await runPromptTurn(async () => {
+			const turnPromise = runPromptTurn(async () => {
 				try {
 					await runQueuedTask(options.sessionId, task, {
 						sharedClient,
@@ -3364,23 +3577,25 @@ async function runSessionQueueOwner(options) {
 						onPromptActive: async () => {
 							turnController.markPromptActive();
 							await applyPendingCancel();
-						}
+						},
+						handleProcessInterrupts: false
 					});
 				} finally {
 					checkpointPerfMetricsCapture();
 				}
 			});
+			shutdown.setActiveTurn(turnPromise);
+			try {
+				await turnPromise;
+			} finally {
+				shutdown.clearActiveTurn(turnPromise);
+			}
 		}
 	} finally {
-		await closeQueueOwnerRuntime({
-			lease,
-			owner,
-			heartbeatTimer,
-			turnController,
-			sharedClient,
-			sessionId: options.sessionId,
-			verbose: options.verbose
-		});
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+		process.off("SIGHUP", onSignal);
+		await shutdown.shutdown();
 	}
 }
 async function sendSession(options) {
@@ -3695,6 +3910,12 @@ function asRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
+function parseJsonRpcErrorSummary(message) {
+	const fallback = parseJsonRpcErrorMessage(message);
+	if (!fallback) return;
+	const details = asRecord(asRecord(message.error)?.data)?.details;
+	return typeof details === "string" && details.trim().length > 0 ? details.trim() : fallback;
+}
 function extractJsonRpcMethod(message) {
 	return Object.hasOwn(message, "method") ? message.method?.toString() : void 0;
 }
@@ -4060,7 +4281,7 @@ var TextOutputFormatter = class {
 			this.renderDone(stopReason);
 			return;
 		}
-		const errorMessage = parseJsonRpcErrorMessage(message);
+		const errorMessage = parseJsonRpcErrorSummary(message);
 		if (errorMessage) this.onError({
 			code: "RUNTIME",
 			origin: "acp",
@@ -4286,7 +4507,11 @@ var QuietOutputFormatter = class {
 			this.flushMetadata(message);
 		}
 	}
-	onError(_params) {}
+	onError(params) {
+		const qualifier = params.detailCode ? `${params.code} ${params.detailCode}` : params.code;
+		const message = preferredAcpErrorDetails(params.acp) ?? params.message;
+		this.stderr.write(`[acpx] error: ${qualifier} ${message.replace(/\r\n?|\n/g, " ")}\n`);
+	}
 	onPermissionEscalation(_event) {}
 	flush() {}
 	flushBufferedOutput() {
@@ -4347,6 +4572,10 @@ var QuietOutputFormatter = class {
 		if (typeof cost === "string" && cost.trim()) return `[acpx] cost: ${cost.trim()}`;
 	}
 };
+function preferredAcpErrorDetails(acp) {
+	const details = asRecord(acp?.data)?.details;
+	return typeof details === "string" && details.trim().length > 0 ? details.trim() : void 0;
+}
 function createOutputFormatter(format, options = {}) {
 	const stdout = options.stdout ?? process.stdout;
 	const stderr = options.stderr ?? process.stderr;
@@ -4361,4 +4590,4 @@ function createOutputFormatter(format, options = {}) {
 //#endregion
 export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as g, isProcessAlive as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
 
-//# sourceMappingURL=output-Smw6kFL_.js.map
+//# sourceMappingURL=output-CjdF5rHk.js.map