acpx 0.11.2 → 0.12.1

package/dist/{output-Smw6kFL_.js → output-fNqTAsFQ.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-DQp4JSHD.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) {
@@ -103,18 +104,26 @@ function isQueueOwnerHeartbeatStale(owner) {
 }
 async function ensureQueueDir() {
 	const baseDir = queueBaseDir();
-	await fs$1.mkdir(baseDir, {
-		recursive: true,
-		mode: 448
-	});
-	await fs$1.chmod(baseDir, 448);
+	try {
+		await fs$1.mkdir(baseDir, {
+			recursive: true,
+			mode: 448
+		});
+		await fs$1.chmod(baseDir, 448);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to prepare queue directory ${baseDir}: ${message}`, { cause: error });
+	}
 	const socketDir = queueSocketBaseDir();
-	if (socketDir) {
+	if (socketDir) try {
 		await fs$1.mkdir(socketDir, {
 			recursive: true,
 			mode: 448
 		});
 		await fs$1.chmod(socketDir, 448);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Failed to prepare queue socket directory ${socketDir}: ${message}`, { cause: error });
 	}
 }
 async function removeSocketFile(socketPath) {
@@ -160,13 +169,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 +762,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 +805,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 +837,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 +845,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 +928,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 +945,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 +964,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 +1047,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 		return false;
 	}
 	enqueuePromptRequest(socket, request) {
+		this.taskSockets.add(socket);
 		const task = {
 			requestId: request.requestId,
 			message: request.message,
@@ -1026,7 +1069,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 				});
 			},
 			close: () => {
-				if (!socket.destroyed) socket.end();
+				this.endSocket(socket);
 			}
 		};
 		if (!this.enqueue(task)) return;
@@ -1038,19 +1081,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 +1156,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 +1168,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;
@@ -1273,6 +1318,7 @@ async function submitToQueueOwner(owner, options) {
 		owner,
 		request,
 		onAccepted: ({ resolve }) => {
+			options.onQueueAccepted?.();
 			options.outputFormatter.setContext({ sessionId: options.sessionId });
 			if (!options.waitForCompletion) resolve({
 				queued: true,
@@ -2274,7 +2320,9 @@ function writeQueueOwnerPayloadFile(payload) {
 	});
 	return payloadPath;
 }
-function buildQueueOwnerSpawnOptions(payloadFilePath) {
+/** Max stderr bytes retained for cold-start diagnostics. */
+const QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES = 4e3;
+function buildQueueOwnerSpawnOptions(payloadFilePath, opts) {
 	const env = {
 		...process.env,
 		[QUEUE_OWNER_PAYLOAD_FILE_ENV]: payloadFilePath
@@ -2282,14 +2330,77 @@ function buildQueueOwnerSpawnOptions(payloadFilePath) {
 	delete env[QUEUE_OWNER_PAYLOAD_ENV];
 	return {
 		detached: true,
-		stdio: "ignore",
+		stdio: opts?.captureStderr === true ? [
+			"ignore",
+			"ignore",
+			"pipe"
+		] : "ignore",
 		env,
 		windowsHide: true
 	};
 }
+function formatQueueOwnerStartupFailure(params) {
+	const parts = [`Session queue owner failed to start for session ${params.sessionId}`];
+	if (params.exit.spawnError) parts.push(`spawn error: ${params.exit.spawnError.message}`);
+	else if (params.exit.exited) {
+		const codePart = params.exit.code === null ? "null" : String(params.exit.code);
+		const signalPart = params.exit.signal ? `, signal ${params.exit.signal}` : "";
+		parts.push(`exited with code ${codePart}${signalPart} before binding its socket`);
+	}
+	const tail = params.logTail.trim();
+	if (tail.length > 0) parts.push(`stderr:\n${tail}`);
+	return parts.join(": ");
+}
 function spawnQueueOwnerProcess(options) {
 	const payloadPath = writeQueueOwnerPayloadFile(JSON.stringify(options));
-	spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath)).unref();
+	let exited = false;
+	let code = null;
+	let signal = null;
+	let spawnError;
+	let capturing = true;
+	let stderrTail = Buffer.alloc(0);
+	const child = spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath, { captureStderr: true }));
+	const stopStartupCapture = () => {
+		if (!capturing) return;
+		capturing = false;
+		const stderr = child.stderr;
+		if (!stderr) return;
+		stderr.removeAllListeners("data");
+		stderr.on("data", () => {});
+		stderr.resume();
+		stderr.unref();
+	};
+	child.stderr?.on("data", (chunk) => {
+		if (!capturing) return;
+		const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+		const combined = Buffer.concat([stderrTail, buf]);
+		stderrTail = combined.length > 4e3 ? combined.subarray(combined.length - QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES) : combined;
+	});
+	child.stderr?.on("error", () => {});
+	child.on("error", (error) => {
+		spawnError = error;
+	});
+	child.on("close", (exitCode, exitSignal) => {
+		exited = true;
+		code = exitCode;
+		signal = exitSignal;
+		stopStartupCapture();
+	});
+	child.unref();
+	return {
+		pid: child.pid,
+		getExitState: () => ({
+			exited,
+			code,
+			signal,
+			...spawnError ? { spawnError } : {}
+		}),
+		readLogTail: (maxBytes = QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES) => {
+			const start = Math.max(0, stderrTail.length - maxBytes);
+			return stderrTail.subarray(start).toString("utf8");
+		},
+		stopStartupCapture
+	};
 }
 //#endregion
 //#region src/session/events.ts
@@ -2527,6 +2638,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 +2792,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 +2848,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 +2857,7 @@ function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatt
 		onClientAvailable: options.onClientAvailable,
 		onClientClosed: options.onClientClosed,
 		onPromptActive: options.onPromptActive,
+		handleProcessInterrupts: options.handleProcessInterrupts,
 		client: options.sharedClient
 	};
 }
@@ -2739,6 +2902,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 +2925,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 +2988,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 +3064,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 +3112,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 +3140,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;
 	};
@@ -2995,7 +3167,8 @@ async function runSessionPrompt(options) {
 	const savePromptSuccess = async (response) => {
 		await flushPendingMessages(false);
 		output.flush();
-		record.lastUsedAt = isoNow();
+		const now = isoNow();
+		record.lastUsedAt = now;
 		record.closed = false;
 		record.closedAt = void 0;
 		record.protocolVersion = client.initializeResult?.protocolVersion;
@@ -3006,37 +3179,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 +3238,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 +3255,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 +3273,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 +3319,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 +3341,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,7 +3356,8 @@ 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;
-async function submitToRunningOwner(options, waitForCompletion) {
+const QUEUE_OWNER_ACTIVE_TURN_CANCEL_GRACE_MS = 750;
+async function submitToRunningOwner(options, waitForCompletion, extras) {
 	return await trySubmitToRunningOwner({
 		sessionId: options.sessionId,
 		message: promptToDisplayText(options.prompt),
@@ -3178,7 +3374,8 @@ async function submitToRunningOwner(options, waitForCompletion) {
 		promptRetries: options.promptRetries,
 		waitForCompletion,
 		verbose: options.verbose,
-		sessionOptions: options.sessionOptions
+		sessionOptions: options.sessionOptions,
+		onQueueAccepted: extras?.onQueueAccepted
 	});
 }
 function createQueueOwnerSharedClient(options, sessionRecord) {
@@ -3245,6 +3442,9 @@ function logDeferredCancelFailure(error, verbose) {
 	if (!verbose) return;
 	process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
 }
+function queueOwnerExitIsFatal(exit) {
+	return exit.exited && (exit.spawnError !== void 0 || exit.code !== 0 || exit.signal !== null);
+}
 function logQueueOwnerReady(params) {
 	if (!params.verbose) return;
 	process.stderr.write(`[acpx] queue owner ready for session ${params.sessionId} (ttlMs=${params.ttlMs}, maxQueueDepth=${params.maxQueueDepth})\n`);
@@ -3252,8 +3452,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 +3465,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 +3578,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 +3620,7 @@ async function runSessionQueueOwner(options) {
 				refreshQueueOwnerLease(lease, { queueDepth }).catch(() => {});
 			}
 		});
+		applyRequestedShutdown(owner, shutdown);
 		logQueueOwnerReady({
 			sessionId: options.sessionId,
 			ttlMs,
@@ -3338,16 +3628,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,37 +3656,67 @@ 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) {
 	const waitForCompletion = options.waitForCompletion !== false;
 	const queuedToOwner = await submitToRunningOwner(options, waitForCompletion);
 	if (queuedToOwner) return queuedToOwner;
-	spawnQueueOwnerProcess(queueOwnerRuntimeOptionsFromSend(options));
+	const owner = spawnQueueOwnerProcess(queueOwnerRuntimeOptionsFromSend(options));
+	const onQueueAccepted = () => {
+		owner.stopStartupCapture();
+	};
 	for (let attempt = 0; attempt < QUEUE_OWNER_STARTUP_MAX_ATTEMPTS; attempt += 1) {
-		const queued = await submitToRunningOwner(options, waitForCompletion);
-		if (queued) return queued;
+		const queued = await submitToRunningOwner(options, waitForCompletion, { onQueueAccepted });
+		if (queued) {
+			owner.stopStartupCapture();
+			return queued;
+		}
+		const exit = owner.getExitState();
+		if (queueOwnerExitIsFatal(exit)) {
+			const message = formatQueueOwnerStartupFailure({
+				sessionId: options.sessionId,
+				exit,
+				logTail: owner.readLogTail()
+			});
+			owner.stopStartupCapture();
+			throw new Error(message);
+		}
 		await waitMs(50);
 	}
-	throw new Error(`Session queue owner failed to start for session ${options.sessionId}`);
+	const finalExit = owner.getExitState();
+	const message = formatQueueOwnerStartupFailure({
+		sessionId: options.sessionId,
+		exit: finalExit.exited ? finalExit : {
+			exited: false,
+			code: null,
+			signal: null
+		},
+		logTail: owner.readLogTail()
+	});
+	owner.stopStartupCapture();
+	throw new Error(message);
 }
+const queueOwnerRuntimeTestInternals = { queueOwnerExitIsFatal };
 //#endregion
 //#region src/session/session.ts
 var session_exports = /* @__PURE__ */ __exportAll({
@@ -3417,6 +3739,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	mergeConnectedModelState: () => mergeConnectedModelState,
 	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
 	pruneSessions: () => pruneSessions,
+	queueOwnerRuntimeTestInternals: () => queueOwnerRuntimeTestInternals,
 	runOnce: () => runOnce,
 	runQueuedTask: () => runQueuedTask,
 	runSessionQueueOwner: () => runSessionQueueOwner,
@@ -3695,6 +4018,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 +4389,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 +4615,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 +4680,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 +4698,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-fNqTAsFQ.js.map