acpx 0.6.1 → 0.8.0

package/dist/output-BL9XRWzS.js

@@ -0,0 +1,3712 @@
+import { $ as getPerfMetricsSnapshot, A as parsePromptStopReason, B as normalizeName, C as mergeSessionOptions, Ct as formatErrorMessage, D as extractSessionUpdateNotification, E as AcpClient, F as findSession, H as resolveSessionRecord, I as findSessionByDirectoryWalk, J as sessionEventActivePath, K as defaultSessionEventLog, L as isoNow, Mt as OUTPUT_ERROR_CODES, N as absolutePath, Nt as OUTPUT_ERROR_ORIGINS, O as isAcpJsonRpcMessage, Ot as toAcpErrorPayload, P as findGitRepositoryRoot, Q as formatPerfMetric, R as listSessions, Rt as QueueConnectionError, S as trimConversationForRuntime, T as sessionOptionsFromRecord, Tt as normalizeOutputError, U as writeSessionRecord, V as pruneSessions, X as sessionEventSegmentPath, Y as sessionEventLockPath, _ as cloneSessionConversation, _t as withTimeout, a as applyConversation, at as startPerfTimer, b as recordPromptSubmission, c as applyRequestedModelIfAdvertised, d as setDesiredConfigOption, et as incrementPerfCounter, f as setDesiredModeId, ft as promptToDisplayText, g as cloneSessionAcpxState, gt as withInterrupt, h as applyConfigOptionsToRecord, ht as TimeoutError, i as connectAndLoadSession, it as setPerfGauge, k as parseJsonRpcErrorMessage, l as assertRequestedModelSupported, lt as isPromptInput, m as syncAdvertisedModelState, mt as InterruptedError, n as runPromptTurn, nt as recordPerfDuration, o as applyLifecycleSnapshotToRecord, p as setDesiredModelId, pt as textPrompt, q as sessionBaseDir, r as withConnectedSession, rt as resetPerfMetrics, st as normalizeRuntimeSessionId, t as LiveSessionCheckpoint, tt as measurePerf, u as setCurrentModelId, v as createSessionConversation, w as persistSessionOptions, wt as isRetryablePromptError, x as recordSessionUpdate, y as recordClientOperation, z as listSessionsForAgent, zt as QueueProtocolError } from "./live-checkpoint-B9ctAuqV.js";
+import fs, { realpathSync } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import { spawn } from "node:child_process";
+import { createHash, randomInt, randomUUID } from "node:crypto";
+import net from "node:net";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/cli/session/contracts.ts
+const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
+function normalizeQueueOwnerTtlMs(ttlMs) {
+	if (ttlMs == null) return DEFAULT_QUEUE_OWNER_TTL_MS;
+	if (!Number.isFinite(ttlMs) || ttlMs < 0) return DEFAULT_QUEUE_OWNER_TTL_MS;
+	return Math.round(ttlMs);
+}
+//#endregion
+//#region src/cli/queue/paths.ts
+function shortHash(value, length) {
+	return createHash("sha256").update(value).digest("hex").slice(0, length);
+}
+function queueKeyForSession(sessionId) {
+	return shortHash(sessionId, 24);
+}
+function queueBaseDir(homeDir = os.homedir()) {
+	return path.join(homeDir, ".acpx", "queues");
+}
+function queueSocketBaseDir(homeDir = os.homedir()) {
+	if (process.platform === "win32") return;
+	return path.join("/tmp", `acpx-${shortHash(homeDir, 10)}`);
+}
+function queueLockFilePath(sessionId, homeDir = os.homedir()) {
+	return path.join(queueBaseDir(homeDir), `${queueKeyForSession(sessionId)}.lock`);
+}
+function queueSocketPath(sessionId, homeDir = os.homedir()) {
+	const key = queueKeyForSession(sessionId);
+	if (process.platform === "win32") return `\\\\.\\pipe\\acpx-${key}`;
+	return path.join(queueSocketBaseDir(homeDir) ?? "/tmp", `${key}.sock`);
+}
+//#endregion
+//#region src/cli/queue/lease-store.ts
+const PROCESS_EXIT_GRACE_MS = 1500;
+const PROCESS_POLL_MS = 50;
+const QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
+function parseQueueOwnerRecord(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const record = raw;
+	if (!Number.isInteger(record.pid) || record.pid <= 0 || typeof record.sessionId !== "string" || typeof record.socketPath !== "string" || typeof record.createdAt !== "string" || typeof record.heartbeatAt !== "string" || !Number.isInteger(record.ownerGeneration) || record.ownerGeneration <= 0 || !Number.isInteger(record.queueDepth) || record.queueDepth < 0) return null;
+	return {
+		pid: record.pid,
+		sessionId: record.sessionId,
+		socketPath: record.socketPath,
+		createdAt: record.createdAt,
+		heartbeatAt: record.heartbeatAt,
+		ownerGeneration: record.ownerGeneration,
+		queueDepth: record.queueDepth
+	};
+}
+function createOwnerGeneration() {
+	return randomInt(1, 2 ** 48);
+}
+function nowIso() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isQueueOwnerHeartbeatStale(owner) {
+	const heartbeatMs = Date.parse(owner.heartbeatAt);
+	if (!Number.isFinite(heartbeatMs)) return true;
+	return Date.now() - heartbeatMs > QUEUE_OWNER_STALE_HEARTBEAT_MS;
+}
+async function ensureQueueDir() {
+	const baseDir = queueBaseDir();
+	await fs$1.mkdir(baseDir, {
+		recursive: true,
+		mode: 448
+	});
+	await fs$1.chmod(baseDir, 448);
+	const socketDir = queueSocketBaseDir();
+	if (socketDir) {
+		await fs$1.mkdir(socketDir, {
+			recursive: true,
+			mode: 448
+		});
+		await fs$1.chmod(socketDir, 448);
+	}
+}
+async function removeSocketFile(socketPath) {
+	if (process.platform === "win32") return;
+	try {
+		await fs$1.unlink(socketPath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function waitForProcessExit(pid, timeoutMs) {
+	const deadline = Date.now() + Math.max(0, timeoutMs);
+	while (Date.now() <= deadline) {
+		if (!isProcessAlive(pid)) return true;
+		await waitMs(PROCESS_POLL_MS);
+	}
+	return !isProcessAlive(pid);
+}
+async function cleanupStaleQueueOwner(sessionId, owner) {
+	const lockPath = queueLockFilePath(sessionId);
+	await removeSocketFile(owner?.socketPath ?? queueSocketPath(sessionId)).catch(() => {});
+	await fs$1.unlink(lockPath).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+}
+async function readQueueOwnerRecord(sessionId) {
+	const lockPath = queueLockFilePath(sessionId);
+	try {
+		const payload = await fs$1.readFile(lockPath, "utf8");
+		return parseQueueOwnerRecord(JSON.parse(payload)) ?? void 0;
+	} catch {
+		return;
+	}
+}
+function isProcessAlive(pid) {
+	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function terminateProcess(pid) {
+	if (!isProcessAlive(pid)) return false;
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		return false;
+	}
+	if (await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS)) return true;
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch {
+		return false;
+	}
+	await waitForProcessExit(pid, PROCESS_EXIT_GRACE_MS);
+	return true;
+}
+async function ensureOwnerIsUsable(sessionId, owner) {
+	const alive = isProcessAlive(owner.pid);
+	const stale = isQueueOwnerHeartbeatStale(owner);
+	if (alive && !stale) return true;
+	if (alive) await terminateProcess(owner.pid).catch(() => {});
+	await cleanupStaleQueueOwner(sessionId, owner);
+	return false;
+}
+async function readQueueOwnerStatus(sessionId) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	const alive = await ensureOwnerIsUsable(sessionId, owner);
+	if (!alive) return;
+	return {
+		pid: owner.pid,
+		socketPath: owner.socketPath,
+		heartbeatAt: owner.heartbeatAt,
+		ownerGeneration: owner.ownerGeneration,
+		queueDepth: owner.queueDepth,
+		alive,
+		stale: isQueueOwnerHeartbeatStale(owner)
+	};
+}
+async function tryAcquireQueueOwnerLease(sessionId, nowIsoFactory = nowIso) {
+	await ensureQueueDir();
+	const lockPath = queueLockFilePath(sessionId);
+	const socketPath = queueSocketPath(sessionId);
+	const createdAt = nowIsoFactory();
+	const ownerGeneration = createOwnerGeneration();
+	const payload = JSON.stringify({
+		pid: process.pid,
+		sessionId,
+		socketPath,
+		createdAt,
+		heartbeatAt: createdAt,
+		ownerGeneration,
+		queueDepth: 0
+	}, null, 2);
+	try {
+		await fs$1.writeFile(lockPath, `${payload}\n`, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		await removeSocketFile(socketPath).catch(() => {});
+		return {
+			sessionId,
+			lockPath,
+			socketPath,
+			createdAt,
+			ownerGeneration
+		};
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const owner = await readQueueOwnerRecord(sessionId);
+		if (!owner) {
+			await cleanupStaleQueueOwner(sessionId, owner);
+			return;
+		}
+		if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) {
+			if (isProcessAlive(owner.pid)) await terminateProcess(owner.pid).catch(() => {});
+			await cleanupStaleQueueOwner(sessionId, owner);
+		}
+		return;
+	}
+}
+async function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
+	const payload = JSON.stringify({
+		pid: process.pid,
+		sessionId: lease.sessionId,
+		socketPath: lease.socketPath,
+		createdAt: lease.createdAt,
+		heartbeatAt: nowIsoFactory(),
+		ownerGeneration: lease.ownerGeneration,
+		queueDepth: Math.max(0, Math.round(options.queueDepth))
+	}, null, 2);
+	await fs$1.writeFile(lease.lockPath, `${payload}\n`, { encoding: "utf8" });
+}
+async function releaseQueueOwnerLease(lease) {
+	await removeSocketFile(lease.socketPath).catch(() => {});
+	await fs$1.unlink(lease.lockPath).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+}
+async function terminateQueueOwnerForSession(sessionId) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	if (isProcessAlive(owner.pid)) await terminateProcess(owner.pid);
+	await cleanupStaleQueueOwner(sessionId, owner);
+}
+async function waitMs(ms) {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+//#endregion
+//#region src/cli/queue/ipc-transport.ts
+const QUEUE_CONNECT_ATTEMPTS = 40;
+const SOCKET_CONNECTION_TIMEOUT_MS = 5e3;
+function shouldRetryQueueConnect(error) {
+	const code = error.code;
+	return code === "ENOENT" || code === "ECONNREFUSED";
+}
+async function connectToSocket(socketPath, timeoutMs = SOCKET_CONNECTION_TIMEOUT_MS) {
+	return await new Promise((resolve, reject) => {
+		const socket = net.createConnection(socketPath);
+		let settled = false;
+		const timeout = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			socket.destroy();
+			reject(/* @__PURE__ */ new Error(`Connection to ${socketPath} timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		const onConnect = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			socket.off("error", onError);
+			resolve(socket);
+		};
+		const onError = (error) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			socket.off("connect", onConnect);
+			reject(error);
+		};
+		socket.once("connect", onConnect);
+		socket.once("error", onError);
+	});
+}
+async function connectToQueueOwner(owner, maxAttempts = QUEUE_CONNECT_ATTEMPTS) {
+	let lastError;
+	const attempts = Math.max(1, Math.trunc(maxAttempts));
+	for (let attempt = 0; attempt < attempts; attempt += 1) try {
+		return await measurePerf("queue.connect", async () => await connectToSocket(owner.socketPath));
+	} catch (error) {
+		lastError = error;
+		if (!shouldRetryQueueConnect(error)) throw error;
+		await waitMs(50);
+	}
+	if (lastError && !shouldRetryQueueConnect(lastError)) throw lastError;
+}
+//#endregion
+//#region src/cli/queue/ipc-health.ts
+async function probeQueueOwnerHealth(sessionId) {
+	const ownerRecord = await readQueueOwnerRecord(sessionId);
+	if (!ownerRecord) return {
+		sessionId,
+		hasLease: false,
+		healthy: false,
+		socketReachable: false,
+		pidAlive: false
+	};
+	const owner = await readQueueOwnerStatus(sessionId);
+	if (!owner) return {
+		sessionId,
+		hasLease: false,
+		healthy: false,
+		socketReachable: false,
+		pidAlive: false
+	};
+	const pidAlive = owner.alive;
+	let socketReachable = false;
+	try {
+		const socket = await connectToQueueOwner(ownerRecord, 2);
+		if (socket) {
+			socketReachable = true;
+			if (!socket.destroyed) socket.end();
+		}
+	} catch {
+		socketReachable = false;
+	}
+	return {
+		sessionId,
+		hasLease: true,
+		healthy: socketReachable,
+		socketReachable,
+		pidAlive,
+		pid: owner.pid,
+		socketPath: owner.socketPath,
+		ownerGeneration: owner.ownerGeneration,
+		queueDepth: owner.queueDepth
+	};
+}
+//#endregion
+//#region src/cli/queue/messages.ts
+function asRecord$2(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function isPermissionMode(value) {
+	return value === "approve-all" || value === "approve-reads" || value === "deny-all";
+}
+function isSessionResumePolicy(value) {
+	return value === "allow-new" || value === "same-session-only";
+}
+function isNonInteractivePermissionPolicy(value) {
+	return value === "deny" || value === "fail";
+}
+function isPermissionPolicy(value) {
+	if (value == null) return false;
+	if (typeof value !== "object" || Array.isArray(value)) return false;
+	const record = value;
+	for (const key of [
+		"autoApprove",
+		"autoDeny",
+		"escalate"
+	]) {
+		const entry = record[key];
+		if (entry == null) continue;
+		if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")) return false;
+	}
+	return record.defaultAction == null || record.defaultAction === "approve" || record.defaultAction === "deny" || record.defaultAction === "escalate";
+}
+function isOutputErrorCode(value) {
+	return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
+}
+function isOutputErrorOrigin(value) {
+	return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
+}
+function isPermissionEscalationEvent(value) {
+	const event = asRecord$2(value);
+	return event?.type === "permission_escalation" && typeof event.sessionId === "string" && typeof event.toolCallId === "string" && typeof event.toolTitle === "string" && event.action === "escalate" && typeof event.message === "string" && typeof event.timestamp === "string" && (event.toolName == null || typeof event.toolName === "string") && (event.toolKind == null || typeof event.toolKind === "string") && (event.matchedRule == null || typeof event.matchedRule === "string");
+}
+function parseSessionOptions(value) {
+	if (value == null) return;
+	const record = asRecord$2(value);
+	if (!record) return null;
+	const sessionOptions = {};
+	if (record.model != null) {
+		if (typeof record.model !== "string" || record.model.trim().length === 0) return null;
+		sessionOptions.model = record.model;
+	}
+	if (record.allowedTools != null) {
+		if (!Array.isArray(record.allowedTools)) return null;
+		const allowedTools = record.allowedTools.filter((tool) => typeof tool === "string");
+		if (allowedTools.length !== record.allowedTools.length) return null;
+		sessionOptions.allowedTools = allowedTools;
+	}
+	if (record.maxTurns != null) {
+		if (typeof record.maxTurns !== "number" || !Number.isFinite(record.maxTurns)) return null;
+		sessionOptions.maxTurns = Math.max(1, Math.round(record.maxTurns));
+	}
+	if (record.systemPrompt != null) if (typeof record.systemPrompt === "string") sessionOptions.systemPrompt = record.systemPrompt;
+	else {
+		const systemPrompt = asRecord$2(record.systemPrompt);
+		if (!systemPrompt || typeof systemPrompt.append !== "string") return null;
+		sessionOptions.systemPrompt = { append: systemPrompt.append };
+	}
+	return sessionOptions;
+}
+function parseOwnerGeneration(value) {
+	if (value == null) return;
+	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
+	return value;
+}
+function parseNonNegativeInteger(value) {
+	if (value == null) return;
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return null;
+	return Math.round(value);
+}
+function parseQueueRequest(raw) {
+	const request = asRecord$2(raw);
+	if (!request) return null;
+	if (typeof request.type !== "string" || typeof request.requestId !== "string") return null;
+	const ownerGeneration = parseOwnerGeneration(request.ownerGeneration);
+	if (ownerGeneration === null) return null;
+	const timeoutRaw = request.timeoutMs;
+	const timeoutMs = typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.round(timeoutRaw) : void 0;
+	if (request.type === "submit_prompt") {
+		const resumePolicy = request.resumePolicy == null ? void 0 : isSessionResumePolicy(request.resumePolicy) ? request.resumePolicy : null;
+		const nonInteractivePermissions = request.nonInteractivePermissions == null ? void 0 : isNonInteractivePermissionPolicy(request.nonInteractivePermissions) ? request.nonInteractivePermissions : null;
+		const permissionPolicy = request.permissionPolicy == null ? void 0 : isPermissionPolicy(request.permissionPolicy) ? request.permissionPolicy : null;
+		const suppressSdkConsoleErrors = request.suppressSdkConsoleErrors == null ? void 0 : typeof request.suppressSdkConsoleErrors === "boolean" ? request.suppressSdkConsoleErrors : null;
+		const promptRetries = parseNonNegativeInteger(request.promptRetries);
+		const sessionOptions = parseSessionOptions(request.sessionOptions);
+		const prompt = request.prompt == null ? void 0 : isPromptInput(request.prompt) ? request.prompt : null;
+		if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || resumePolicy === null || prompt === null || nonInteractivePermissions === null || permissionPolicy === null || suppressSdkConsoleErrors === null || promptRetries === null || sessionOptions === null || typeof request.waitForCompletion !== "boolean") return null;
+		return {
+			type: "submit_prompt",
+			requestId: request.requestId,
+			ownerGeneration,
+			message: request.message,
+			prompt: prompt ?? textPrompt(request.message),
+			permissionMode: request.permissionMode,
+			...resumePolicy !== void 0 ? { resumePolicy } : {},
+			nonInteractivePermissions,
+			...permissionPolicy !== void 0 ? { permissionPolicy } : {},
+			timeoutMs,
+			...suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors } : {},
+			...promptRetries !== void 0 ? { promptRetries } : {},
+			waitForCompletion: request.waitForCompletion,
+			...sessionOptions !== void 0 ? { sessionOptions } : {}
+		};
+	}
+	if (request.type === "cancel_prompt") return {
+		type: "cancel_prompt",
+		requestId: request.requestId,
+		ownerGeneration
+	};
+	if (request.type === "close_session") return {
+		type: "close_session",
+		requestId: request.requestId,
+		ownerGeneration,
+		timeoutMs
+	};
+	if (request.type === "set_mode") {
+		if (typeof request.modeId !== "string" || request.modeId.trim().length === 0) return null;
+		return {
+			type: "set_mode",
+			requestId: request.requestId,
+			ownerGeneration,
+			modeId: request.modeId,
+			timeoutMs
+		};
+	}
+	if (request.type === "set_model") {
+		if (typeof request.modelId !== "string" || request.modelId.trim().length === 0) return null;
+		return {
+			type: "set_model",
+			requestId: request.requestId,
+			ownerGeneration,
+			modelId: request.modelId,
+			timeoutMs
+		};
+	}
+	if (request.type === "set_config_option") {
+		if (typeof request.configId !== "string" || request.configId.trim().length === 0 || typeof request.value !== "string" || request.value.trim().length === 0) return null;
+		return {
+			type: "set_config_option",
+			requestId: request.requestId,
+			ownerGeneration,
+			configId: request.configId,
+			value: request.value,
+			timeoutMs
+		};
+	}
+	return null;
+}
+function parseSessionSendResult(raw) {
+	const result = asRecord$2(raw);
+	if (!result) return null;
+	if (typeof result.stopReason !== "string" || typeof result.sessionId !== "string" || typeof result.resumed !== "boolean") return null;
+	const permissionStats = asRecord$2(result.permissionStats);
+	const record = asRecord$2(result.record);
+	if (!permissionStats || !record) return null;
+	if (!(typeof permissionStats.requested === "number" && typeof permissionStats.approved === "number" && typeof permissionStats.denied === "number" && typeof permissionStats.cancelled === "number")) return null;
+	if (!(typeof record.acpxRecordId === "string" && typeof record.acpSessionId === "string" && typeof record.agentCommand === "string" && typeof record.cwd === "string" && typeof record.createdAt === "string" && typeof record.lastUsedAt === "string" && Array.isArray(record.messages) && typeof record.updated_at === "string" && typeof record.lastSeq === "number" && Number.isInteger(record.lastSeq) && !!record.eventLog && typeof record.eventLog === "object")) return null;
+	return result;
+}
+function parseQueueOwnerMessage(raw) {
+	const message = asRecord$2(raw);
+	if (!message || typeof message.type !== "string") return null;
+	if (typeof message.requestId !== "string") return null;
+	const ownerGeneration = parseOwnerGeneration(message.ownerGeneration);
+	if (ownerGeneration === null) return null;
+	if (message.type === "accepted") return {
+		type: "accepted",
+		requestId: message.requestId,
+		ownerGeneration
+	};
+	if (message.type === "event") {
+		if (!isAcpJsonRpcMessage(message.message)) return null;
+		return {
+			type: "event",
+			requestId: message.requestId,
+			ownerGeneration,
+			message: message.message
+		};
+	}
+	if (message.type === "permission_escalation") {
+		if (!isPermissionEscalationEvent(message.event)) return null;
+		return {
+			type: "permission_escalation",
+			requestId: message.requestId,
+			ownerGeneration,
+			event: message.event
+		};
+	}
+	if (message.type === "result") {
+		const parsedResult = parseSessionSendResult(message.result);
+		if (!parsedResult) return null;
+		return {
+			type: "result",
+			requestId: message.requestId,
+			ownerGeneration,
+			result: parsedResult
+		};
+	}
+	if (message.type === "cancel_result") {
+		if (typeof message.cancelled !== "boolean") return null;
+		return {
+			type: "cancel_result",
+			requestId: message.requestId,
+			ownerGeneration,
+			cancelled: message.cancelled
+		};
+	}
+	if (message.type === "set_mode_result") {
+		if (typeof message.modeId !== "string") return null;
+		return {
+			type: "set_mode_result",
+			requestId: message.requestId,
+			ownerGeneration,
+			modeId: message.modeId
+		};
+	}
+	if (message.type === "set_model_result") {
+		if (typeof message.modelId !== "string") return null;
+		return {
+			type: "set_model_result",
+			requestId: message.requestId,
+			ownerGeneration,
+			modelId: message.modelId
+		};
+	}
+	if (message.type === "set_config_option_result") {
+		const response = asRecord$2(message.response);
+		if (!response || !Array.isArray(response.configOptions)) return null;
+		return {
+			type: "set_config_option_result",
+			requestId: message.requestId,
+			ownerGeneration,
+			response
+		};
+	}
+	if (message.type === "error") {
+		if (typeof message.message !== "string" || !isOutputErrorCode(message.code) || !isOutputErrorOrigin(message.origin)) return null;
+		const detailCode = typeof message.detailCode === "string" && message.detailCode.trim().length > 0 ? message.detailCode : void 0;
+		const retryable = typeof message.retryable === "boolean" ? message.retryable : void 0;
+		const acp = toAcpErrorPayload(message.acp);
+		const outputAlreadyEmitted = typeof message.outputAlreadyEmitted === "boolean" ? message.outputAlreadyEmitted : void 0;
+		return {
+			type: "error",
+			requestId: message.requestId,
+			ownerGeneration,
+			code: message.code,
+			detailCode,
+			origin: message.origin,
+			message: message.message,
+			retryable,
+			acp,
+			...outputAlreadyEmitted === void 0 ? {} : { outputAlreadyEmitted }
+		};
+	}
+	return null;
+}
+//#endregion
+//#region src/cli/queue/ipc-server.ts
+function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
+	return {
+		type: "error",
+		requestId,
+		ownerGeneration: void 0,
+		code: "RUNTIME",
+		detailCode,
+		origin: "queue",
+		retryable: options.retryable,
+		message
+	};
+}
+function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
+	const normalized = normalizeOutputError(error, {
+		defaultCode: "RUNTIME",
+		origin: "queue",
+		detailCode,
+		retryable: options.retryable
+	});
+	return {
+		type: "error",
+		requestId,
+		code: normalized.code,
+		detailCode: normalized.detailCode,
+		origin: normalized.origin,
+		message: normalized.message,
+		retryable: normalized.retryable,
+		acp: normalized.acp
+	};
+}
+function writeQueueMessage(socket, message) {
+	if (socket.destroyed || !socket.writable) return;
+	socket.write(`${JSON.stringify(message)}\n`);
+}
+var SessionQueueOwner = class SessionQueueOwner {
+	server;
+	controlHandlers;
+	ownerGeneration;
+	maxQueueDepth;
+	onQueueDepthChanged;
+	pending = [];
+	waiters = [];
+	closed = false;
+	constructor(server, controlHandlers, lease, options) {
+		this.server = server;
+		this.controlHandlers = controlHandlers;
+		this.ownerGeneration = lease.ownerGeneration;
+		this.maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth));
+		this.onQueueDepthChanged = options.onQueueDepthChanged;
+	}
+	static async start(lease, controlHandlers, options = { maxQueueDepth: 16 }) {
+		const ownerRef = { current: void 0 };
+		const server = net.createServer((socket) => {
+			ownerRef.current?.handleConnection(socket);
+		});
+		ownerRef.current = new SessionQueueOwner(server, controlHandlers, lease, options);
+		await new Promise((resolve, reject) => {
+			const onListening = () => {
+				server.off("error", onError);
+				resolve();
+			};
+			const onError = (error) => {
+				server.off("listening", onListening);
+				reject(error);
+			};
+			server.once("listening", onListening);
+			server.once("error", onError);
+			server.listen(lease.socketPath);
+		});
+		return ownerRef.current;
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const waiter of this.waiters.splice(0)) waiter(void 0);
+		for (const task of this.pending.splice(0)) {
+			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner shutting down before prompt execution", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
+			task.close();
+		}
+		this.emitQueueDepth();
+		await new Promise((resolve) => {
+			this.server.close(() => resolve());
+		});
+	}
+	async nextTask(timeoutMs) {
+		if (this.pending.length > 0) {
+			const task = this.pending.shift();
+			this.emitQueueDepth();
+			if (task) recordPerfDuration("queue.owner.wait_ms", Date.now() - task.enqueuedAt);
+			return task;
+		}
+		if (this.closed) return;
+		return await new Promise((resolve) => {
+			const timer = timeoutMs != null && setTimeout(() => {
+				const index = this.waiters.indexOf(waiter);
+				if (index >= 0) this.waiters.splice(index, 1);
+				resolve(void 0);
+			}, Math.max(0, timeoutMs));
+			const waiter = (task) => {
+				if (timer) clearTimeout(timer);
+				resolve(task);
+			};
+			this.waiters.push(waiter);
+		});
+	}
+	queueDepth() {
+		return this.pending.length;
+	}
+	emitQueueDepth() {
+		this.onQueueDepthChanged?.(this.pending.length);
+	}
+	enqueue(task) {
+		if (this.closed) {
+			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
+			task.close();
+			return;
+		}
+		const waiter = this.waiters.shift();
+		if (waiter) {
+			waiter(task);
+			return;
+		}
+		if (this.pending.length >= this.maxQueueDepth) {
+			if (task.waitForCompletion) task.send({
+				...makeQueueOwnerError(task.requestId, `Queue owner is overloaded (${this.pending.length}/${this.maxQueueDepth} queued)`, "QUEUE_OWNER_OVERLOADED", { retryable: true }),
+				ownerGeneration: this.ownerGeneration
+			});
+			task.close();
+			return;
+		}
+		this.pending.push(task);
+		this.emitQueueDepth();
+	}
+	handleControlRequest(options) {
+		writeQueueMessage(options.socket, {
+			type: "accepted",
+			requestId: options.requestId,
+			ownerGeneration: this.ownerGeneration
+		});
+		options.run().then((message) => {
+			writeQueueMessage(options.socket, {
+				...message,
+				ownerGeneration: this.ownerGeneration
+			});
+		}).catch((error) => {
+			writeQueueMessage(options.socket, {
+				...makeQueueOwnerErrorFromUnknown(options.requestId, error, "QUEUE_CONTROL_REQUEST_FAILED"),
+				ownerGeneration: this.ownerGeneration
+			});
+		}).finally(() => {
+			if (!options.socket.destroyed) options.socket.end();
+		});
+	}
+	handleConnection(socket) {
+		socket.setEncoding("utf8");
+		if (this.closed) {
+			writeQueueMessage(socket, makeQueueOwnerError("unknown", "Queue owner is closed", "QUEUE_OWNER_CLOSED", { retryable: true }));
+			socket.end();
+			return;
+		}
+		let buffer = "";
+		let handled = false;
+		const fail = (requestId, message, detailCode) => {
+			writeQueueMessage(socket, {
+				...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
+				ownerGeneration: this.ownerGeneration
+			});
+			socket.end();
+		};
+		const processLine = (line) => {
+			if (handled) return;
+			handled = true;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				fail("unknown", "Invalid queue request payload", "QUEUE_REQUEST_PAYLOAD_INVALID_JSON");
+				return;
+			}
+			const request = parseQueueRequest(parsed);
+			if (!request) {
+				fail("unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
+				return;
+			}
+			if (request.ownerGeneration !== void 0 && this.ownerGeneration !== void 0 && request.ownerGeneration !== this.ownerGeneration) {
+				fail(request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
+				return;
+			}
+			if (request.type === "cancel_prompt") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => ({
+						type: "cancel_result",
+						requestId: request.requestId,
+						cancelled: await this.controlHandlers.cancelPrompt()
+					})
+				});
+				return;
+			}
+			if (request.type === "close_session") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => ({
+						type: "close_session_result",
+						requestId: request.requestId,
+						closed: await this.controlHandlers.closeSession(request.timeoutMs)
+					})
+				});
+				return;
+			}
+			if (request.type === "set_mode") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => {
+						await this.controlHandlers.setSessionMode(request.modeId, request.timeoutMs);
+						return {
+							type: "set_mode_result",
+							requestId: request.requestId,
+							modeId: request.modeId
+						};
+					}
+				});
+				return;
+			}
+			if (request.type === "set_model") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => {
+						await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+						return {
+							type: "set_model_result",
+							requestId: request.requestId,
+							modelId: request.modelId
+						};
+					}
+				});
+				return;
+			}
+			if (request.type === "set_config_option") {
+				this.handleControlRequest({
+					socket,
+					requestId: request.requestId,
+					run: async () => ({
+						type: "set_config_option_result",
+						requestId: request.requestId,
+						response: await this.controlHandlers.setSessionConfigOption(request.configId, request.value, request.timeoutMs)
+					})
+				});
+				return;
+			}
+			const task = {
+				requestId: request.requestId,
+				message: request.message,
+				prompt: request.prompt ?? textPrompt(request.message),
+				permissionMode: request.permissionMode,
+				resumePolicy: request.resumePolicy,
+				nonInteractivePermissions: request.nonInteractivePermissions,
+				permissionPolicy: request.permissionPolicy,
+				timeoutMs: request.timeoutMs,
+				suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
+				promptRetries: request.promptRetries,
+				sessionOptions: request.sessionOptions,
+				waitForCompletion: request.waitForCompletion,
+				enqueuedAt: Date.now(),
+				send: (message) => {
+					writeQueueMessage(socket, {
+						...message,
+						ownerGeneration: this.ownerGeneration
+					});
+				},
+				close: () => {
+					if (!socket.destroyed) socket.end();
+				}
+			};
+			writeQueueMessage(socket, {
+				type: "accepted",
+				requestId: request.requestId,
+				ownerGeneration: this.ownerGeneration
+			});
+			if (!request.waitForCompletion) task.close();
+			this.enqueue(task);
+		};
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			let index = buffer.indexOf("\n");
+			while (index >= 0) {
+				const line = buffer.slice(0, index).trim();
+				buffer = buffer.slice(index + 1);
+				if (line.length > 0) processLine(line);
+				index = buffer.indexOf("\n");
+			}
+		});
+		socket.on("error", () => {});
+	}
+};
+//#endregion
+//#region src/cli/queue/ipc.ts
+const MAX_MESSAGE_BUFFER_SIZE = 10 * 1024 * 1024;
+const STALE_OWNER_PROTOCOL_DETAIL_CODES = new Set(["QUEUE_PROTOCOL_MALFORMED_MESSAGE", "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE"]);
+async function maybeRecoverStaleOwnerAfterProtocolMismatch(params) {
+	if (!(params.error instanceof QueueProtocolError)) return false;
+	const detailCode = params.error.detailCode;
+	if (!detailCode || !STALE_OWNER_PROTOCOL_DETAIL_CODES.has(detailCode)) return false;
+	await terminateQueueOwnerForSession(params.sessionId).catch(() => {});
+	incrementPerfCounter("queue.owner.stale_recovered");
+	if (params.verbose) process.stderr.write(`[acpx] dropped stale queue owner metadata after protocol mismatch for session ${params.sessionId} (${detailCode})\n`);
+	return true;
+}
+function assertOwnerGeneration(owner, message) {
+	if (owner.ownerGeneration !== void 0 && message.ownerGeneration !== void 0 && message.ownerGeneration !== owner.ownerGeneration) throw new QueueProtocolError("Queue owner returned mismatched generation", {
+		detailCode: "QUEUE_OWNER_GENERATION_MISMATCH",
+		origin: "queue",
+		retryable: true
+	});
+	return message;
+}
+function makeMalformedQueueMessageError() {
+	return new QueueProtocolError("Queue owner sent malformed message", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function parseQueueOwnerResponseLine(owner, requestId, line) {
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch {
+		throw new QueueProtocolError("Queue owner sent invalid JSON payload", {
+			detailCode: "QUEUE_PROTOCOL_INVALID_JSON",
+			origin: "queue",
+			retryable: true
+		});
+	}
+	const parsedMessage = parseQueueOwnerMessage(parsed);
+	if (!parsedMessage) throw makeMalformedQueueMessageError();
+	const message = assertOwnerGeneration(owner, parsedMessage);
+	if (message.requestId !== requestId) throw makeMalformedQueueMessageError();
+	return message;
+}
+async function runQueueOwnerRequest(options) {
+	const socket = await connectToQueueOwner(options.owner);
+	if (!socket) return;
+	socket.setEncoding("utf8");
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let buffer = "";
+		const state = { acknowledged: false };
+		const finishResolve = (result) => {
+			if (settled) return;
+			settled = true;
+			socket.removeAllListeners();
+			if (!socket.destroyed) socket.end();
+			resolve(result);
+		};
+		const finishReject = (error) => {
+			if (settled) return;
+			settled = true;
+			socket.removeAllListeners();
+			if (!socket.destroyed) socket.destroy();
+			reject(error);
+		};
+		const controls = {
+			state,
+			resolve: finishResolve,
+			reject: finishReject
+		};
+		const processLine = (line) => {
+			let message;
+			try {
+				message = parseQueueOwnerResponseLine(options.owner, options.request.requestId, line);
+			} catch (error) {
+				finishReject(error);
+				return;
+			}
+			if (message.type === "accepted") {
+				state.acknowledged = true;
+				options.onAccepted?.(controls);
+				return;
+			}
+			options.onMessage(message, controls);
+		};
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			if (buffer.length > 10485760) {
+				socket.destroy();
+				finishReject(/* @__PURE__ */ new Error(`Message buffer exceeded ${MAX_MESSAGE_BUFFER_SIZE} bytes`));
+				return;
+			}
+			let index = buffer.indexOf("\n");
+			while (index >= 0) {
+				const line = buffer.slice(0, index).trim();
+				buffer = buffer.slice(index + 1);
+				if (line.length > 0) processLine(line);
+				index = buffer.indexOf("\n");
+			}
+		});
+		socket.once("error", (error) => {
+			finishReject(error);
+		});
+		socket.once("close", () => {
+			if (settled) return;
+			options.onClose(controls);
+		});
+		socket.write(`${JSON.stringify(options.request)}\n`);
+	});
+}
+async function submitToQueueOwner(owner, options) {
+	const requestId = randomUUID();
+	const request = {
+		type: "submit_prompt",
+		requestId,
+		ownerGeneration: owner.ownerGeneration,
+		message: options.message,
+		prompt: options.prompt,
+		permissionMode: options.permissionMode,
+		resumePolicy: options.resumePolicy,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		timeoutMs: options.timeoutMs,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		promptRetries: options.promptRetries ?? 0,
+		waitForCompletion: options.waitForCompletion,
+		sessionOptions: options.sessionOptions
+	};
+	options.outputFormatter.setContext({ sessionId: options.sessionId });
+	return await runQueueOwnerRequest({
+		owner,
+		request,
+		onAccepted: ({ resolve }) => {
+			options.outputFormatter.setContext({ sessionId: options.sessionId });
+			if (!options.waitForCompletion) resolve({
+				queued: true,
+				sessionId: options.sessionId,
+				requestId
+			});
+		},
+		onMessage: (message, { state, resolve, reject }) => {
+			if (message.type === "error") {
+				options.outputFormatter.setContext({ sessionId: options.sessionId });
+				const queueErrorAlreadyEmitted = options.errorEmissionPolicy?.queueErrorAlreadyEmitted ?? true;
+				if (!(message.outputAlreadyEmitted === true) || !queueErrorAlreadyEmitted) {
+					options.outputFormatter.onError({
+						code: message.code ?? "RUNTIME",
+						detailCode: message.detailCode,
+						origin: message.origin ?? "queue",
+						message: message.message,
+						retryable: message.retryable,
+						acp: message.acp
+					});
+					options.outputFormatter.flush();
+				}
+				reject(new QueueConnectionError(message.message, {
+					outputCode: message.code,
+					detailCode: message.detailCode,
+					origin: message.origin ?? "queue",
+					retryable: message.retryable,
+					acp: message.acp,
+					...queueErrorAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
+				}));
+				return;
+			}
+			if (!state.acknowledged) {
+				reject(new QueueConnectionError("Queue owner did not acknowledge request", {
+					detailCode: "QUEUE_ACK_MISSING",
+					origin: "queue",
+					retryable: true
+				}));
+				return;
+			}
+			if (message.type === "event") {
+				options.outputFormatter.onAcpMessage(message.message);
+				return;
+			}
+			if (message.type === "permission_escalation") {
+				options.outputFormatter.onPermissionEscalation(message.event);
+				return;
+			}
+			if (message.type === "result") {
+				options.outputFormatter.flush();
+				resolve(message.result);
+				return;
+			}
+			reject(new QueueProtocolError("Queue owner returned unexpected response", {
+				detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+				origin: "queue",
+				retryable: true
+			}));
+		},
+		onClose: ({ state, resolve, reject }) => {
+			if (!state.acknowledged) {
+				reject(new QueueConnectionError("Queue owner disconnected before acknowledging request", {
+					detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+					origin: "queue",
+					retryable: true
+				}));
+				return;
+			}
+			if (!options.waitForCompletion) {
+				resolve({
+					queued: true,
+					sessionId: options.sessionId,
+					requestId
+				});
+				return;
+			}
+			reject(new QueueConnectionError("Queue owner disconnected before prompt completion", {
+				detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+				origin: "queue",
+				retryable: true
+			}));
+		}
+	});
+}
+async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
+	return await runQueueOwnerRequest({
+		owner,
+		request,
+		onMessage: (message, { state, resolve, reject }) => {
+			if (message.type === "error") {
+				reject(new QueueConnectionError(message.message, {
+					outputCode: message.code,
+					detailCode: message.detailCode,
+					origin: message.origin ?? "queue",
+					retryable: message.retryable,
+					acp: message.acp
+				}));
+				return;
+			}
+			if (!state.acknowledged) {
+				reject(new QueueConnectionError("Queue owner did not acknowledge request", {
+					detailCode: "QUEUE_ACK_MISSING",
+					origin: "queue",
+					retryable: true
+				}));
+				return;
+			}
+			if (!isExpectedResponse(message)) {
+				reject(new QueueProtocolError("Queue owner returned unexpected response", {
+					detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+					origin: "queue",
+					retryable: true
+				}));
+				return;
+			}
+			resolve(message);
+		},
+		onClose: ({ state, reject }) => {
+			if (!state.acknowledged) {
+				reject(new QueueConnectionError("Queue owner disconnected before acknowledging request", {
+					detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+					origin: "queue",
+					retryable: true
+				}));
+				return;
+			}
+			reject(new QueueConnectionError("Queue owner disconnected before responding", {
+				detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+				origin: "queue",
+				retryable: true
+			}));
+		}
+	});
+}
+async function submitCancelToQueueOwner(owner) {
+	const request = {
+		type: "cancel_prompt",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "cancel_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched cancel response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return response.cancelled;
+}
+async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
+	const request = {
+		type: "set_mode",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		modeId,
+		timeoutMs
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_mode_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_mode response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return true;
+}
+async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
+	const request = {
+		type: "set_model",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		modelId,
+		timeoutMs
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_model_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_model response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return true;
+}
+async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
+	const request = {
+		type: "set_config_option",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		configId,
+		value,
+		timeoutMs
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_config_option_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_config_option response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return response.response;
+}
+async function submitCloseSessionToQueueOwner(owner, timeoutMs) {
+	const request = {
+		type: "close_session",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		timeoutMs
+	};
+	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "close_session_result");
+	if (!response) return;
+	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched close_session response", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+	return response.closed;
+}
+async function trySubmitToRunningOwner(options) {
+	const owner = await readQueueOwnerRecord(options.sessionId);
+	if (!owner) return;
+	let submitted;
+	try {
+		submitted = await submitToQueueOwner(owner, options);
+	} catch (error) {
+		if (await maybeRecoverStaleOwnerAfterProtocolMismatch({
+			sessionId: options.sessionId,
+			owner,
+			error,
+			verbose: options.verbose
+		})) return;
+		throw error;
+	}
+	if (submitted) {
+		if (options.verbose) process.stderr.write(`[acpx] queued prompt on active owner pid ${owner.pid} for session ${options.sessionId}\n`);
+		return submitted;
+	}
+	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting queue requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function tryCloseSessionOnRunningOwner(options) {
+	const owner = await readQueueOwnerRecord(options.sessionId);
+	if (!owner) return;
+	const closed = await submitCloseSessionToQueueOwner(owner, options.timeoutMs);
+	if (closed !== void 0) {
+		if (options.verbose) process.stderr.write(`[acpx] requested session/close on active owner pid ${owner.pid} for session ${options.sessionId}\n`);
+		return closed;
+	}
+	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting close_session requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function tryCancelOnRunningOwner(options) {
+	const owner = await readQueueOwnerRecord(options.sessionId);
+	if (!owner) return;
+	const cancelled = await submitCancelToQueueOwner(owner);
+	if (cancelled !== void 0) {
+		if (options.verbose) process.stderr.write(`[acpx] requested cancel on active owner pid ${owner.pid} for session ${options.sessionId}\n`);
+		return cancelled;
+	}
+	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting cancel requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	if (await submitSetModeToQueueOwner(owner, modeId, timeoutMs)) {
+		if (verbose) process.stderr.write(`[acpx] requested session/set_mode on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return true;
+	}
+	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting set_mode requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	if (await submitSetModelToQueueOwner(owner, modelId, timeoutMs)) {
+		if (verbose) process.stderr.write(`[acpx] requested session/set_model on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return true;
+	}
+	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting set_model requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
+	const owner = await readQueueOwnerRecord(sessionId);
+	if (!owner) return;
+	const response = await submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs);
+	if (response) {
+		if (verbose) process.stderr.write(`[acpx] requested session/set_config_option on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return response;
+	}
+	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
+	throw new QueueConnectionError("Session queue owner is running but not accepting set_config_option requests", {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+//#endregion
+//#region src/cli/session/prompt-runner.ts
+function buildDirectConnectedSessionOptions(options, run) {
+	return {
+		sessionRecordId: options.sessionRecordId,
+		loadRecord: resolveSessionRecord,
+		saveRecord: writeSessionRecord,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose,
+		onClientAvailable: (controller) => {
+			options.onClientAvailable?.(controller);
+		},
+		onClientClosed: options.onClientClosed,
+		run
+	};
+}
+function toSessionMutationResult(result) {
+	return {
+		record: result.record,
+		resumed: result.resumed,
+		loadError: result.loadError
+	};
+}
+async function runSessionSetModeDirect(options) {
+	return toSessionMutationResult(await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		await withTimeout(client.setSessionMode(sessionId, options.modeId), options.timeoutMs);
+		setDesiredModeId(record, options.modeId);
+	})));
+}
+async function runSessionSetModelDirect(options) {
+	return toSessionMutationResult(await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		await withTimeout(client.setSessionModel(sessionId, options.modelId), options.timeoutMs);
+		setDesiredModelId(record, options.modelId);
+		setCurrentModelId(record, options.modelId);
+	})));
+}
+async function runSessionSetConfigOptionDirect(options) {
+	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value), options.timeoutMs);
+		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		else setDesiredConfigOption(record, options.configId, options.value);
+		return response;
+	}));
+	return {
+		record: result.record,
+		response: result.value,
+		resumed: result.resumed,
+		loadError: result.loadError
+	};
+}
+//#endregion
+//#region src/cli/session/session-control.ts
+async function cancelSessionPrompt(options) {
+	const cancelled = await tryCancelOnRunningOwner(options);
+	return {
+		sessionId: options.sessionId,
+		cancelled: cancelled === true
+	};
+}
+async function setSessionMode(options) {
+	if (await trySetModeOnRunningOwner(options.sessionId, options.modeId, options.timeoutMs, options.verbose)) {
+		const record = await resolveSessionRecord(options.sessionId);
+		setDesiredModeId(record, options.modeId);
+		await writeSessionRecord(record);
+		return {
+			record,
+			resumed: false
+		};
+	}
+	return await runSessionSetModeDirect({
+		sessionRecordId: options.sessionId,
+		modeId: options.modeId,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose
+	});
+}
+async function setSessionModel(options) {
+	if (await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose)) {
+		const record = await resolveSessionRecord(options.sessionId);
+		setDesiredModelId(record, options.modelId);
+		setCurrentModelId(record, options.modelId);
+		await writeSessionRecord(record);
+		return {
+			record,
+			resumed: false
+		};
+	}
+	return await runSessionSetModelDirect({
+		sessionRecordId: options.sessionId,
+		modelId: options.modelId,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose
+	});
+}
+async function setSessionConfigOption(options) {
+	const ownerResponse = await trySetConfigOptionOnRunningOwner(options.sessionId, options.configId, options.value, options.timeoutMs, options.verbose);
+	if (ownerResponse) {
+		const record = await resolveSessionRecord(options.sessionId);
+		if (options.configId === "mode") setDesiredModeId(record, options.value);
+		else setDesiredConfigOption(record, options.configId, options.value);
+		await writeSessionRecord(record);
+		return {
+			record,
+			response: ownerResponse,
+			resumed: false
+		};
+	}
+	return await runSessionSetConfigOptionDirect({
+		sessionRecordId: options.sessionId,
+		configId: options.configId,
+		value: options.value,
+		mcpServers: options.mcpServers,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		timeoutMs: options.timeoutMs,
+		verbose: options.verbose
+	});
+}
+function firstAgentCommandToken(command) {
+	const trimmed = command.trim();
+	if (!trimmed) return;
+	const token = trimmed.split(/\s+/, 1)[0];
+	return token.length > 0 ? token : void 0;
+}
+async function isLikelyMatchingProcess(pid, agentCommand) {
+	const expectedToken = firstAgentCommandToken(agentCommand);
+	if (!expectedToken) return false;
+	const procCmdline = `/proc/${pid}/cmdline`;
+	try {
+		const argv = (await fs$1.readFile(procCmdline, "utf8")).split("\0").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+		if (argv.length === 0) return false;
+		const executableBase = path.basename(argv[0]);
+		const expectedBase = path.basename(expectedToken);
+		return executableBase === expectedBase || argv.some((entry) => path.basename(entry) === expectedBase);
+	} catch {
+		return true;
+	}
+}
+async function closeSession(sessionId) {
+	const record = await resolveSessionRecord(sessionId);
+	await tryCloseSessionOnRunningOwner({ sessionId: record.acpxRecordId }).catch(() => {});
+	await terminateQueueOwnerForSession(record.acpxRecordId);
+	if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record.agentCommand)) await terminateProcess(record.pid);
+	record.pid = void 0;
+	record.closed = true;
+	record.closedAt = isoNow();
+	await writeSessionRecord(record);
+	return record;
+}
+//#endregion
+//#region src/cli/session/session-management.ts
+async function createSessionRecordWithClient(client, options) {
+	const cwd = absolutePath(options.cwd);
+	await withTimeout(client.start(), options.timeoutMs);
+	let sessionId;
+	let agentSessionId;
+	let sessionResult;
+	let sessionModels;
+	let requestedModelApplied = false;
+	if (options.resumeSessionId) {
+		if (!client.supportsLoadSession()) throw new Error(`Agent command "${options.agentCommand}" does not support session/load; cannot resume session ${options.resumeSessionId}`);
+		try {
+			const loadedSession = await withTimeout(client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
+			sessionId = options.resumeSessionId;
+			agentSessionId = normalizeRuntimeSessionId(loadedSession.agentSessionId);
+			sessionResult = loadedSession;
+			sessionModels = loadedSession.models;
+			requestedModelApplied = await applyRequestedModelIfAdvertised({
+				client,
+				sessionId,
+				requestedModel: options.sessionOptions?.model,
+				models: sessionModels,
+				agentCommand: options.agentCommand,
+				timeoutMs: options.timeoutMs
+			});
+		} catch (error) {
+			throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
+		}
+	} else {
+		const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
+		sessionId = createdSession.sessionId;
+		agentSessionId = normalizeRuntimeSessionId(createdSession.agentSessionId);
+		sessionResult = createdSession;
+		sessionModels = createdSession.models;
+		requestedModelApplied = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId,
+			requestedModel: options.sessionOptions?.model,
+			models: sessionModels,
+			agentCommand: options.agentCommand,
+			timeoutMs: options.timeoutMs
+		});
+	}
+	const lifecycle = client.getAgentLifecycleSnapshot();
+	const now = isoNow();
+	const record = {
+		schema: "acpx.session.v1",
+		acpxRecordId: sessionId,
+		acpSessionId: sessionId,
+		agentSessionId,
+		agentCommand: options.agentCommand,
+		cwd,
+		name: normalizeName(options.name),
+		createdAt: now,
+		lastUsedAt: now,
+		lastSeq: 0,
+		lastRequestId: void 0,
+		eventLog: defaultSessionEventLog(sessionId),
+		closed: false,
+		closedAt: void 0,
+		pid: lifecycle.pid,
+		agentStartedAt: lifecycle.startedAt,
+		protocolVersion: client.initializeResult?.protocolVersion,
+		agentCapabilities: client.initializeResult?.agentCapabilities,
+		...createSessionConversation(now),
+		acpx: {}
+	};
+	persistSessionOptions(record, options.sessionOptions);
+	applyConfigOptionsToRecord(record, sessionResult);
+	syncAdvertisedModelState(record, sessionModels);
+	if (requestedModelApplied) setCurrentModelId(record, options.sessionOptions?.model);
+	await writeSessionRecord(record);
+	return record;
+}
+async function createSessionWithClient(options) {
+	const client = new AcpClient({
+		agentCommand: options.agentCommand,
+		cwd: absolutePath(options.cwd),
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		verbose: options.verbose,
+		sessionOptions: options.sessionOptions
+	});
+	try {
+		return {
+			record: await withInterrupt(async () => await createSessionRecordWithClient(client, options), async () => {
+				await client.close();
+			}),
+			client
+		};
+	} catch (error) {
+		await client.close();
+		throw error;
+	}
+}
+async function createSession(options) {
+	const { record, client } = await createSessionWithClient(options);
+	try {
+		return record;
+	} finally {
+		await client.close();
+	}
+}
+async function ensureSession(options) {
+	const cwd = absolutePath(options.cwd);
+	const gitRoot = findGitRepositoryRoot(cwd);
+	const walkBoundary = options.walkBoundary ?? gitRoot ?? cwd;
+	const existing = await findSessionByDirectoryWalk({
+		agentCommand: options.agentCommand,
+		cwd,
+		name: options.name,
+		boundary: walkBoundary
+	});
+	if (existing) {
+		const requestedModel = options.sessionOptions?.model;
+		if (requestedModel) return {
+			record: (await setSessionModel({
+				sessionId: existing.acpxRecordId,
+				modelId: requestedModel,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				terminal: options.terminal,
+				timeoutMs: options.timeoutMs,
+				verbose: options.verbose
+			})).record,
+			created: false
+		};
+		return {
+			record: existing,
+			created: false
+		};
+	}
+	return {
+		record: await createSession({
+			agentCommand: options.agentCommand,
+			cwd,
+			name: options.name,
+			resumeSessionId: options.resumeSessionId,
+			mcpServers: options.mcpServers,
+			permissionMode: options.permissionMode,
+			nonInteractivePermissions: options.nonInteractivePermissions,
+			permissionPolicy: options.permissionPolicy,
+			authCredentials: options.authCredentials,
+			authPolicy: options.authPolicy,
+			terminal: options.terminal,
+			timeoutMs: options.timeoutMs,
+			verbose: options.verbose,
+			sessionOptions: options.sessionOptions
+		}),
+		created: true
+	};
+}
+//#endregion
+//#region src/perf-metrics-capture.ts
+const PERF_METRICS_FILE_ENV = "ACPX_PERF_METRICS_FILE";
+let installed = false;
+let flushed = false;
+let captureFilePath;
+let captureRole = "cli";
+let captureArgv = [];
+let captureSequence = 0;
+function shouldCapture() {
+	return typeof captureFilePath === "string" && captureFilePath.trim().length > 0;
+}
+function buildPayload(reason) {
+	return {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		pid: process.pid,
+		ppid: process.ppid,
+		role: captureRole,
+		argv: captureArgv,
+		cwd: process.cwd(),
+		sequence: captureSequence,
+		reason,
+		metrics: getPerfMetricsSnapshot()
+	};
+}
+function writePerfMetricsCapture(reason, resetAfterWrite) {
+	if (!shouldCapture()) return false;
+	const payload = buildPayload(reason);
+	const metrics = payload.metrics;
+	if (!(Object.keys(metrics.counters ?? {}).length > 0 || Object.keys(metrics.gauges ?? {}).length > 0 || Object.keys(metrics.timings ?? {}).length > 0)) return false;
+	try {
+		fs.mkdirSync(path.dirname(captureFilePath), { recursive: true });
+		fs.appendFileSync(captureFilePath, `${JSON.stringify(payload)}\n`, "utf8");
+		captureSequence += 1;
+		if (resetAfterWrite) resetPerfMetrics();
+		return true;
+	} catch {
+		return false;
+	}
+}
+function checkpointPerfMetricsCapture() {
+	flushed = false;
+	writePerfMetricsCapture("checkpoint", true);
+}
+function flushPerfMetricsCapture(reason = "exit") {
+	if (flushed || !shouldCapture()) return;
+	flushed = true;
+	writePerfMetricsCapture(reason, false);
+}
+function installPerfMetricsCapture(options = {}) {
+	captureFilePath = options.filePath ?? process.env[PERF_METRICS_FILE_ENV];
+	if (!shouldCapture()) return;
+	resetPerfMetrics();
+	captureRole = options.role ?? captureRole;
+	captureArgv = options.argv ?? [];
+	captureSequence = 0;
+	flushed = false;
+	if (installed) return;
+	installed = true;
+	process.once("exit", () => {
+		flushPerfMetricsCapture("exit");
+	});
+	for (const signal of ["SIGINT", "SIGTERM"]) {
+		const handler = () => {
+			flushPerfMetricsCapture("signal");
+			process.removeListener(signal, handler);
+			process.kill(process.pid, signal);
+		};
+		process.once(signal, handler);
+	}
+}
+//#endregion
+//#region src/cli/queue/owner-turn-controller.ts
+var QueueOwnerTurnController = class {
+	options;
+	state = "idle";
+	pendingCancel = false;
+	activeController;
+	constructor(options) {
+		this.options = options;
+	}
+	get lifecycleState() {
+		return this.state;
+	}
+	get hasPendingCancel() {
+		return this.pendingCancel;
+	}
+	beginTurn() {
+		this.state = "starting";
+		this.pendingCancel = false;
+	}
+	markPromptActive() {
+		if (this.state === "starting" || this.state === "active") this.state = "active";
+	}
+	endTurn() {
+		this.state = "idle";
+		this.pendingCancel = false;
+	}
+	beginClosing() {
+		this.state = "closing";
+		this.pendingCancel = false;
+		this.activeController = void 0;
+	}
+	setActiveController(controller) {
+		this.activeController = controller;
+	}
+	clearActiveController() {
+		this.activeController = void 0;
+	}
+	assertCanHandleControlRequest() {
+		if (this.state === "closing") throw new QueueConnectionError("Queue owner is closing", {
+			detailCode: "QUEUE_OWNER_SHUTTING_DOWN",
+			origin: "queue",
+			retryable: true
+		});
+	}
+	async requestCancel() {
+		const activeController = this.activeController;
+		if (activeController?.hasActivePrompt()) {
+			const cancelled = await activeController.requestCancelActivePrompt();
+			if (cancelled) this.pendingCancel = false;
+			return cancelled;
+		}
+		if (this.state === "starting" || this.state === "active") {
+			this.pendingCancel = true;
+			return true;
+		}
+		return false;
+	}
+	async applyPendingCancel() {
+		const activeController = this.activeController;
+		if (!this.pendingCancel || !activeController || !activeController.hasActivePrompt()) return false;
+		const cancelled = await activeController.requestCancelActivePrompt();
+		if (cancelled) this.pendingCancel = false;
+		return cancelled;
+	}
+	async setSessionMode(modeId, timeoutMs) {
+		this.assertCanHandleControlRequest();
+		const activeController = this.activeController;
+		if (activeController) {
+			await this.options.withTimeout(async () => await activeController.setSessionMode(modeId), timeoutMs);
+			return;
+		}
+		await this.options.setSessionModeFallback(modeId, timeoutMs);
+	}
+	async setSessionModel(modelId, timeoutMs) {
+		this.assertCanHandleControlRequest();
+		const activeController = this.activeController;
+		if (activeController) {
+			await this.options.withTimeout(async () => await activeController.setSessionModel(modelId), timeoutMs);
+			return;
+		}
+		await this.options.setSessionModelFallback(modelId, timeoutMs);
+	}
+	async setSessionConfigOption(configId, value, timeoutMs) {
+		this.assertCanHandleControlRequest();
+		const activeController = this.activeController;
+		if (activeController) return await this.options.withTimeout(async () => await activeController.setSessionConfigOption(configId, value), timeoutMs);
+		return await this.options.setSessionConfigOptionFallback(configId, value, timeoutMs);
+	}
+};
+//#endregion
+//#region src/cli/session/queue-owner-process.ts
+function sanitizeQueueOwnerExecArgv(execArgv = process.execArgv) {
+	const sanitized = [];
+	for (let index = 0; index < execArgv.length; index += 1) {
+		const value = execArgv[index];
+		if (value === "--experimental-test-coverage" || value === "--test") continue;
+		if (value === "--test-name-pattern" || value === "--test-reporter" || value === "--test-reporter-destination") {
+			index += 1;
+			continue;
+		}
+		if (value.startsWith("--test-")) continue;
+		if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value.startsWith("--inspect=") || value.startsWith("--inspect-brk=") || value.startsWith("--inspect-port=") || value.startsWith("--inspect-publish-uid=") || value === "--debug-port" || value.startsWith("--debug-port=")) {
+			if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value === "--debug-port") index += 1;
+			continue;
+		}
+		sanitized.push(value);
+	}
+	return sanitized;
+}
+function buildQueueOwnerArgOverride(entryPath, execArgv = process.execArgv) {
+	const sanitized = sanitizeQueueOwnerExecArgv(execArgv);
+	if (sanitized.length === 0) return null;
+	return JSON.stringify([
+		...sanitized,
+		entryPath,
+		"__queue-owner"
+	]);
+}
+function resolveQueueOwnerSpawnArgs(argv = process.argv) {
+	const override = process.env.ACPX_QUEUE_OWNER_ARGS;
+	if (override) {
+		const parsed = JSON.parse(override);
+		if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string" && value.length > 0)) return [...parsed];
+		throw new Error("acpx self-spawn failed: invalid ACPX_QUEUE_OWNER_ARGS");
+	}
+	const entry = argv[1];
+	if (!entry || entry.trim().length === 0) throw new Error("acpx self-spawn failed: missing CLI entry path");
+	return [realpathSync(entry), "__queue-owner"];
+}
+function queueOwnerRuntimeOptionsFromSend(options) {
+	return {
+		sessionId: options.sessionId,
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		ttlMs: options.ttlMs,
+		maxQueueDepth: options.maxQueueDepth,
+		promptRetries: options.promptRetries,
+		sessionOptions: options.sessionOptions
+	};
+}
+function buildQueueOwnerSpawnOptions(payload) {
+	return {
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			ACPX_QUEUE_OWNER_PAYLOAD: payload
+		},
+		windowsHide: true
+	};
+}
+function spawnQueueOwnerProcess(options) {
+	const payload = JSON.stringify(options);
+	spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payload)).unref();
+}
+//#endregion
+//#region src/session/events.ts
+const LOCK_RETRY_MS = 15;
+const EVENT_LOCK_STALE_MS = 15e3;
+async function ensureSessionDir() {
+	await fs$1.mkdir(sessionBaseDir(), { recursive: true });
+}
+async function pathExists(filePath) {
+	try {
+		await fs$1.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function statSize(filePath) {
+	try {
+		return (await fs$1.stat(filePath)).size;
+	} catch {
+		return 0;
+	}
+}
+async function countExistingSegments(sessionId, maxSegments) {
+	let count = 0;
+	for (let segment = 1; segment <= maxSegments; segment += 1) if (await pathExists(sessionEventSegmentPath(sessionId, segment))) count += 1;
+	if (await pathExists(sessionEventActivePath(sessionId))) count += 1;
+	return count;
+}
+async function rotateSegments(sessionId, maxSegments) {
+	const active = sessionEventActivePath(sessionId);
+	const overflow = sessionEventSegmentPath(sessionId, maxSegments);
+	await fs$1.unlink(overflow).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+	for (let segment = maxSegments - 1; segment >= 1; segment -= 1) {
+		const from = sessionEventSegmentPath(sessionId, segment);
+		const to = sessionEventSegmentPath(sessionId, segment + 1);
+		if (!await pathExists(from)) continue;
+		await fs$1.rename(from, to);
+	}
+	if (await pathExists(active)) await fs$1.rename(active, sessionEventSegmentPath(sessionId, 1));
+}
+function parseEventLockPayload(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		const record = parsed;
+		return {
+			pid: typeof record.pid === "number" ? record.pid : void 0,
+			created_at: typeof record.created_at === "string" ? record.created_at : void 0
+		};
+	} catch {
+		return {};
+	}
+}
+async function removeStaleEventLock(lockPath) {
+	try {
+		const parsed = parseEventLockPayload(await fs$1.readFile(lockPath, "utf8"));
+		const createdAtMs = parsed.created_at ? Date.parse(parsed.created_at) : NaN;
+		const lockAgeMs = Number.isFinite(createdAtMs) ? Date.now() - createdAtMs : Number.POSITIVE_INFINITY;
+		if (isProcessAlive(parsed.pid) && lockAgeMs <= EVENT_LOCK_STALE_MS) return false;
+		await fs$1.unlink(lockPath);
+		incrementPerfCounter("session.events.stale_lock_recovered");
+		return true;
+	} catch (error) {
+		if (error.code === "ENOENT") return true;
+		return false;
+	}
+}
+async function acquireEventsLock(sessionId) {
+	await ensureSessionDir();
+	const lockPath = sessionEventLockPath(sessionId);
+	const payload = JSON.stringify({
+		pid: process.pid,
+		created_at: (/* @__PURE__ */ new Date()).toISOString()
+	}, null, 2);
+	for (;;) try {
+		await fs$1.writeFile(lockPath, `${payload}\n`, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		return { filePath: lockPath };
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		if (await removeStaleEventLock(lockPath)) continue;
+		await new Promise((resolve) => {
+			setTimeout(resolve, LOCK_RETRY_MS);
+		});
+	}
+}
+async function releaseEventsLock(lock) {
+	await fs$1.unlink(lock.filePath).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+}
+var SessionEventWriter = class SessionEventWriter {
+	record;
+	lock;
+	maxSegmentBytes;
+	maxSegments;
+	activePath;
+	activeSizeBytes;
+	segmentCount;
+	closed = false;
+	constructor(record, lock, options, state) {
+		this.record = record;
+		this.lock = lock;
+		this.maxSegmentBytes = options.maxSegmentBytes;
+		this.maxSegments = options.maxSegments;
+		this.activePath = state.activePath;
+		this.activeSizeBytes = state.activeSizeBytes;
+		this.segmentCount = state.segmentCount;
+	}
+	static async open(record, options = {}) {
+		const lock = await acquireEventsLock(record.acpxRecordId);
+		const maxSegmentBytes = options.maxSegmentBytes ?? record.eventLog.max_segment_bytes ?? 67108864;
+		const maxSegments = options.maxSegments ?? record.eventLog.max_segments ?? 5;
+		const activePath = sessionEventActivePath(record.acpxRecordId);
+		const activeSizeBytes = await statSize(activePath);
+		const segmentCount = Number.isInteger(record.eventLog.segment_count) && record.eventLog.segment_count > 0 ? record.eventLog.segment_count : await countExistingSegments(record.acpxRecordId, maxSegments) || 1;
+		return new SessionEventWriter(record, lock, {
+			maxSegmentBytes,
+			maxSegments
+		}, {
+			activePath,
+			activeSizeBytes,
+			segmentCount
+		});
+	}
+	getRecord() {
+		return this.record;
+	}
+	async appendMessage(message, options = {}) {
+		await this.appendMessages([message], options);
+	}
+	async appendMessages(messages, options = {}) {
+		if (this.closed) throw new Error("SessionEventWriter is closed");
+		if (messages.length === 0) return;
+		await ensureSessionDir();
+		await measurePerf("session.events.append_batch", async () => {
+			for (const message of messages) {
+				if (!isAcpJsonRpcMessage(message)) throw new Error("Attempted to persist invalid ACP JSON-RPC payload");
+				const line = `${JSON.stringify(message)}\n`;
+				const lineBytes = Buffer.byteLength(line);
+				if (this.activeSizeBytes > 0 && this.activeSizeBytes + lineBytes > this.maxSegmentBytes) {
+					await rotateSegments(this.record.acpxRecordId, this.maxSegments);
+					this.activePath = sessionEventActivePath(this.record.acpxRecordId);
+					this.activeSizeBytes = 0;
+					this.segmentCount = Math.min(this.segmentCount + 1, this.maxSegments);
+					incrementPerfCounter("session.events.rotate");
+				}
+				await fs$1.appendFile(this.activePath, line, "utf8");
+				this.activeSizeBytes += lineBytes;
+				this.record.lastSeq += 1;
+				if (Object.hasOwn(message, "id")) {
+					const id = message.id;
+					if (typeof id === "string" || typeof id === "number") this.record.lastRequestId = String(id);
+				}
+				const writeTs = (/* @__PURE__ */ new Date()).toISOString();
+				this.record.lastUsedAt = writeTs;
+				this.record.eventLog = {
+					active_path: this.activePath,
+					segment_count: this.segmentCount,
+					max_segment_bytes: this.maxSegmentBytes,
+					max_segments: this.maxSegments,
+					last_write_at: writeTs,
+					last_write_error: null
+				};
+			}
+		});
+		if (options.checkpoint === true) await writeSessionRecord(this.record);
+	}
+	async checkpoint() {
+		if (this.closed) throw new Error("SessionEventWriter is closed");
+		await writeSessionRecord(this.record);
+	}
+	async close(options = {}) {
+		if (this.closed) return;
+		try {
+			if (options.checkpoint !== false) await writeSessionRecord(this.record);
+		} finally {
+			this.closed = true;
+			await releaseEventsLock(this.lock);
+		}
+	}
+};
+//#endregion
+//#region src/cli/session/runtime.ts
+const INTERRUPT_CANCEL_WAIT_MS = 2500;
+var QueueTaskOutputFormatter = class {
+	requestId;
+	send;
+	constructor(task) {
+		this.requestId = task.requestId;
+		this.send = task.send;
+	}
+	setContext(_context) {}
+	onAcpMessage(message) {
+		this.send({
+			type: "event",
+			requestId: this.requestId,
+			message
+		});
+	}
+	onError(params) {
+		this.send({
+			type: "error",
+			requestId: this.requestId,
+			code: params.code,
+			detailCode: params.detailCode,
+			origin: params.origin,
+			message: params.message,
+			retryable: params.retryable,
+			acp: params.acp
+		});
+	}
+	onPermissionEscalation(event) {
+		this.send({
+			type: "permission_escalation",
+			requestId: this.requestId,
+			event
+		});
+	}
+	flush() {}
+};
+const DISCARD_OUTPUT_FORMATTER = {
+	setContext() {},
+	onAcpMessage() {},
+	onError() {},
+	onPermissionEscalation() {},
+	flush() {}
+};
+function toPromptResult(stopReason, sessionId, client) {
+	return {
+		stopReason,
+		sessionId,
+		permissionStats: client.getPermissionStats()
+	};
+}
+async function applyPromptModelIfAdvertised(params) {
+	const requestedModel = typeof params.requestedModel === "string" ? params.requestedModel.trim() : "";
+	if (!requestedModel) return;
+	const availableModels = params.record.acpx?.available_models;
+	assertRequestedModelSupported({
+		requestedModel,
+		models: Array.isArray(availableModels) ? {
+			currentModelId: params.record.acpx?.current_model_id ?? "",
+			availableModels: availableModels.map((modelId) => ({
+				modelId,
+				name: modelId
+			}))
+		} : void 0,
+		agentCommand: params.record.agentCommand,
+		context: "apply"
+	});
+	if (!Array.isArray(availableModels)) return;
+	if (params.record.acpx?.current_model_id === requestedModel) {
+		setDesiredModelId(params.record, requestedModel);
+		return;
+	}
+	await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel), params.timeoutMs);
+	setDesiredModelId(params.record, requestedModel);
+	setCurrentModelId(params.record, requestedModel);
+}
+function jsonRpcIdKey$1(value) {
+	if (typeof value === "string") return `s:${value}`;
+	if (typeof value === "number" && Number.isFinite(value)) return `n:${value}`;
+}
+function extractJsonRpcRequestInfo(message) {
+	const candidate = message;
+	if (typeof candidate.method !== "string") return;
+	const idKey = jsonRpcIdKey$1(candidate.id);
+	if (!idKey) return;
+	return {
+		idKey,
+		method: candidate.method
+	};
+}
+function extractJsonRpcResponseInfo(message) {
+	const candidate = message;
+	const idKey = jsonRpcIdKey$1(candidate.id);
+	if (!idKey) return;
+	const hasError = Object.hasOwn(candidate, "error");
+	if (!hasError && !Object.hasOwn(candidate, "result")) return;
+	return {
+		idKey,
+		hasError
+	};
+}
+function filterRecoverableLoadFallbackOutput(messages) {
+	const requestMethodById = /* @__PURE__ */ new Map();
+	const failedLoadRequestIds = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		const request = extractJsonRpcRequestInfo(message);
+		if (request) {
+			requestMethodById.set(request.idKey, request.method);
+			continue;
+		}
+		const response = extractJsonRpcResponseInfo(message);
+		if (!response || !response.hasError) continue;
+		if (requestMethodById.get(response.idKey) === "session/load") failedLoadRequestIds.add(response.idKey);
+	}
+	if (failedLoadRequestIds.size === 0) return messages;
+	return messages.filter((message) => {
+		const request = extractJsonRpcRequestInfo(message);
+		if (request && request.method === "session/load" && failedLoadRequestIds.has(request.idKey)) return false;
+		const response = extractJsonRpcResponseInfo(message);
+		if (response && failedLoadRequestIds.has(response.idKey)) return false;
+		return true;
+	});
+}
+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`);
+}
+async function runQueuedTask(sessionRecordId, task, options) {
+	const outputFormatter = task.waitForCompletion ? new QueueTaskOutputFormatter(task) : DISCARD_OUTPUT_FORMATTER;
+	try {
+		const result = await runSessionPrompt({
+			sessionRecordId,
+			mcpServers: options.mcpServers,
+			prompt: task.prompt ?? textPrompt(task.message),
+			permissionMode: task.permissionMode,
+			resumePolicy: task.resumePolicy,
+			nonInteractivePermissions: task.nonInteractivePermissions ?? options.nonInteractivePermissions,
+			permissionPolicy: task.permissionPolicy,
+			authCredentials: options.authCredentials,
+			authPolicy: options.authPolicy,
+			outputFormatter,
+			timeoutMs: task.timeoutMs,
+			suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
+			verbose: options.verbose,
+			promptRetries: task.promptRetries ?? options.promptRetries ?? 0,
+			sessionOptions: mergeSessionOptions(task.sessionOptions, options.sessionOptions),
+			onClientAvailable: options.onClientAvailable,
+			onClientClosed: options.onClientClosed,
+			onPromptActive: options.onPromptActive,
+			client: options.sharedClient
+		});
+		if (task.waitForCompletion) task.send({
+			type: "result",
+			requestId: task.requestId,
+			result
+		});
+	} catch (error) {
+		const normalizedError = normalizeOutputError(error, {
+			origin: "runtime",
+			detailCode: "QUEUE_RUNTIME_PROMPT_FAILED"
+		});
+		const alreadyEmitted = error.outputAlreadyEmitted === true;
+		if (task.waitForCompletion) task.send({
+			type: "error",
+			requestId: task.requestId,
+			code: normalizedError.code,
+			detailCode: normalizedError.detailCode,
+			origin: normalizedError.origin,
+			message: normalizedError.message,
+			retryable: normalizedError.retryable,
+			acp: normalizedError.acp,
+			outputAlreadyEmitted: alreadyEmitted
+		});
+		if (error instanceof InterruptedError) throw error;
+	} finally {
+		task.close();
+	}
+}
+async function runSessionPrompt(options) {
+	const stopTotalTimer = startPerfTimer("runtime.prompt.total");
+	const output = options.outputFormatter;
+	const record = await measurePerf("session.resolve_prompt_record", async () => {
+		return await resolveSessionRecord(options.sessionRecordId);
+	});
+	const conversation = cloneSessionConversation(record);
+	let acpxState = cloneSessionAcpxState(record.acpx);
+	const promptStartedAt = isoNow();
+	const promptMessageId = recordPromptSubmission(conversation, options.prompt, promptStartedAt);
+	record.lastPromptAt = promptStartedAt;
+	record.lastUsedAt = promptStartedAt;
+	applyConversation(record, conversation);
+	record.acpx = acpxState;
+	await writeSessionRecord(record);
+	output.setContext({ sessionId: record.acpxRecordId });
+	const eventWriter = await measurePerf("session.events.open", async () => {
+		return await SessionEventWriter.open(record);
+	});
+	const pendingMessages = [];
+	const pendingConnectOutputMessages = [];
+	const sessionOptions = mergeSessionOptions(options.sessionOptions, sessionOptionsFromRecord(record));
+	let bufferingConnectOutput = true;
+	let promptTurnActive = false;
+	let promptTurnHadSideEffects = false;
+	let sawAcpMessage = false;
+	let eventWriterClosed = false;
+	const closeEventWriter = async (checkpoint) => {
+		if (eventWriterClosed) return;
+		eventWriterClosed = true;
+		await eventWriter.close({ checkpoint });
+	};
+	const flushPendingMessages = async (checkpoint = false) => {
+		if (pendingMessages.length === 0) return;
+		const batch = pendingMessages.splice(0);
+		await measurePerf("session.events.flush_pending", async () => {
+			await eventWriter.appendMessages(batch, { checkpoint });
+		});
+	};
+	const preserveClosedState = async () => {
+		const latest = await resolveSessionRecord(record.acpxRecordId).catch(() => void 0);
+		if (!latest?.closed) return;
+		record.closed = true;
+		record.closedAt = latest.closedAt ?? record.closedAt ?? isoNow();
+		record.pid = latest.pid;
+		if (latest.acpx) record.acpx = {
+			...record.acpx,
+			...latest.acpx
+		};
+	};
+	const liveCheckpoint = new LiveSessionCheckpoint({
+		save: async () => {
+			await flushPendingMessages(false);
+			record.lastUsedAt = isoNow();
+			applyConversation(record, conversation);
+			record.acpx = acpxState;
+			await preserveClosedState();
+			await eventWriter.checkpoint();
+		},
+		onError: (error) => {
+			if (options.verbose) process.stderr.write("[acpx] live session checkpoint failed: " + formatErrorMessage(error) + "\n");
+		}
+	});
+	const ownClient = options.client == null;
+	const client = options.client ?? new AcpClient({
+		agentCommand: record.agentCommand,
+		cwd: absolutePath(record.cwd),
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		sessionOptions
+	});
+	client.updateRuntimeOptions({
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		terminal: options.terminal,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose
+	});
+	client.setEventHandlers({
+		onAcpMessage: (direction, message) => {
+			sawAcpMessage = true;
+			pendingMessages.push(message);
+			options.onAcpMessage?.(direction, message);
+		},
+		onAcpOutputMessage: (_direction, message) => {
+			if (bufferingConnectOutput) {
+				pendingConnectOutputMessages.push(message);
+				return;
+			}
+			output.onAcpMessage(message);
+		},
+		onSessionUpdate: (notification) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			acpxState = recordSessionUpdate(conversation, acpxState, notification);
+			trimConversationForRuntime(conversation);
+			liveCheckpoint.request();
+			options.onSessionUpdate?.(notification);
+		},
+		onClientOperation: (operation) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			acpxState = recordClientOperation(conversation, acpxState, operation);
+			trimConversationForRuntime(conversation);
+			liveCheckpoint.request();
+			options.onClientOperation?.(operation);
+		},
+		onPermissionEscalation: (event) => {
+			output.onPermissionEscalation(event);
+			options.onPermissionEscalation?.(event);
+		}
+	});
+	let activeSessionIdForControl = record.acpSessionId;
+	let notifiedClientAvailable = false;
+	const activeController = {
+		hasActivePrompt: () => client.hasActivePrompt(),
+		requestCancelActivePrompt: async () => await client.requestCancelActivePrompt(),
+		setSessionMode: async (modeId) => {
+			await client.setSessionMode(activeSessionIdForControl, modeId);
+		},
+		setSessionModel: async (modelId) => {
+			await client.setSessionModel(activeSessionIdForControl, modelId);
+		},
+		setSessionConfigOption: async (configId, value) => {
+			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+		}
+	};
+	try {
+		return await withInterrupt(async () => {
+			const connectStartedAt = Date.now();
+			const { sessionId: activeSessionId, resumed, loadError } = await measurePerf("runtime.connect_and_load", async () => {
+				try {
+					return await connectAndLoadSession({
+						client,
+						record,
+						resumePolicy: options.resumePolicy,
+						timeoutMs: options.timeoutMs,
+						verbose: options.verbose,
+						activeController,
+						onClientAvailable: (controller) => {
+							options.onClientAvailable?.(controller);
+							notifiedClientAvailable = true;
+						},
+						onConnectedRecord: (connectedRecord) => {
+							connectedRecord.lastPromptAt = isoNow();
+						},
+						onSessionIdResolved: (sessionId) => {
+							activeSessionIdForControl = sessionId;
+						}
+					});
+				} catch (error) {
+					bufferingConnectOutput = false;
+					for (const message of pendingConnectOutputMessages) output.onAcpMessage(message);
+					pendingConnectOutputMessages.length = 0;
+					throw error;
+				}
+			});
+			bufferingConnectOutput = false;
+			const connectOutputMessages = loadError == null ? pendingConnectOutputMessages : filterRecoverableLoadFallbackOutput(pendingConnectOutputMessages);
+			for (const message of connectOutputMessages) output.onAcpMessage(message);
+			pendingConnectOutputMessages.length = 0;
+			if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.connect_and_load", Date.now() - connectStartedAt)}\n`);
+			await applyPromptModelIfAdvertised({
+				client,
+				sessionId: activeSessionId,
+				requestedModel: sessionOptions?.model,
+				record,
+				timeoutMs: options.timeoutMs
+			});
+			output.setContext({ sessionId: record.acpxRecordId });
+			await liveCheckpoint.checkpoint();
+			const maxRetries = options.promptRetries ?? 0;
+			let response;
+			promptTurnActive = true;
+			for (let attempt = 0;; attempt++) try {
+				const promptStartedAt = Date.now();
+				response = await measurePerf("runtime.prompt.agent_turn", async () => {
+					return await runPromptTurn({
+						client,
+						sessionId: activeSessionId,
+						prompt: options.prompt,
+						timeoutMs: options.timeoutMs,
+						conversation,
+						promptMessageId,
+						onPromptStarted: attempt === 0 && options.onPromptActive ? async () => {
+							try {
+								await options.onPromptActive?.();
+							} catch (error) {
+								if (options.verbose) process.stderr.write("[acpx] onPromptActive hook failed: " + formatErrorMessage(error) + "\n");
+							}
+						} : void 0
+					});
+				});
+				if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.agent_turn", Date.now() - promptStartedAt)}\n`);
+				break;
+			} catch (error) {
+				const snapshot = client.getAgentLifecycleSnapshot();
+				const agentCrashed = snapshot.lastExit?.unexpectedDuringPrompt === true;
+				if (attempt < maxRetries && !agentCrashed && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
+					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+					emitPromptRetryNotice({
+						error,
+						delayMs,
+						attempt: attempt + 1,
+						maxRetries,
+						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
+					});
+					await waitMs(delayMs);
+					if (!promptTurnHadSideEffects) continue;
+				}
+				promptTurnActive = false;
+				applyLifecycleSnapshotToRecord(record, snapshot);
+				const lastExit = snapshot.lastExit;
+				if (lastExit?.unexpectedDuringPrompt && options.verbose) process.stderr.write("[acpx] agent disconnected during prompt (" + lastExit.reason + ", exit=" + lastExit.exitCode + ", signal=" + (lastExit.signal ?? "none") + ")\n");
+				const normalizedError = normalizeOutputError(error, { origin: "runtime" });
+				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;
+				propagated.normalizedOutputError = normalizedError;
+				throw propagated;
+			}
+			promptTurnActive = false;
+			await flushPendingMessages(false);
+			output.flush();
+			record.lastUsedAt = isoNow();
+			record.closed = false;
+			record.closedAt = void 0;
+			record.protocolVersion = client.initializeResult?.protocolVersion;
+			record.agentCapabilities = client.initializeResult?.agentCapabilities;
+			applyConversation(record, conversation);
+			record.acpx = acpxState;
+			applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+			stopTotalTimer();
+			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();
+		});
+	} finally {
+		if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.total", stopTotalTimer())}\n`);
+		else stopTotalTimer();
+		if (notifiedClientAvailable) options.onClientClosed?.();
+		client.clearEventHandlers();
+		if (ownClient) await client.close();
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		await liveCheckpoint.flush().catch(() => {});
+		await flushPendingMessages(false).catch(() => {});
+		await preserveClosedState().catch(() => {});
+		await closeEventWriter(true).catch(() => {});
+	}
+}
+async function runOnce(options) {
+	const output = options.outputFormatter;
+	let promptTurnActive = false;
+	let promptTurnHadSideEffects = false;
+	const client = new AcpClient({
+		agentCommand: options.agentCommand,
+		cwd: absolutePath(options.cwd),
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		onAcpMessage: options.onAcpMessage,
+		onAcpOutputMessage: (_direction, message) => output.onAcpMessage(message),
+		onSessionUpdate: (notification) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			options.onSessionUpdate?.(notification);
+		},
+		onClientOperation: (operation) => {
+			if (promptTurnActive) promptTurnHadSideEffects = true;
+			options.onClientOperation?.(operation);
+		},
+		onPermissionEscalation: (event) => {
+			output.onPermissionEscalation(event);
+			options.onPermissionEscalation?.(event);
+		},
+		sessionOptions: options.sessionOptions
+	});
+	try {
+		return await withInterrupt(async () => {
+			await measurePerf("runtime.exec.start", async () => {
+				await withTimeout(client.start(), options.timeoutMs);
+			});
+			const createdSession = await measurePerf("runtime.exec.create_session", async () => {
+				return await withTimeout(client.createSession(absolutePath(options.cwd)), options.timeoutMs);
+			});
+			const sessionId = createdSession.sessionId;
+			await applyRequestedModelIfAdvertised({
+				client,
+				sessionId,
+				requestedModel: options.sessionOptions?.model,
+				models: createdSession.models,
+				agentCommand: options.agentCommand,
+				timeoutMs: options.timeoutMs
+			});
+			output.setContext({ sessionId });
+			const maxRetries = options.promptRetries ?? 0;
+			let response;
+			promptTurnActive = true;
+			for (let attempt = 0;; attempt++) try {
+				response = await measurePerf("runtime.exec.prompt", async () => {
+					return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
+				});
+				break;
+			} catch (error) {
+				if (attempt < maxRetries && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
+					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+					emitPromptRetryNotice({
+						error,
+						delayMs,
+						attempt: attempt + 1,
+						maxRetries,
+						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
+					});
+					await waitMs(delayMs);
+					if (!promptTurnHadSideEffects) continue;
+				}
+				promptTurnActive = false;
+				throw error;
+			}
+			promptTurnActive = false;
+			output.flush();
+			return toPromptResult(response.stopReason, sessionId, client);
+		}, async () => {
+			await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
+			await client.close();
+		});
+	} finally {
+		await client.close();
+	}
+}
+async function sendSessionDirect(options) {
+	return await runSessionPrompt({
+		sessionRecordId: options.sessionId,
+		prompt: options.prompt,
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		resumePolicy: options.resumePolicy,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		outputFormatter: options.outputFormatter,
+		onAcpMessage: options.onAcpMessage,
+		onSessionUpdate: options.onSessionUpdate,
+		onClientOperation: options.onClientOperation,
+		onPermissionEscalation: options.onPermissionEscalation,
+		timeoutMs: options.timeoutMs,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		client: options.client
+	});
+}
+//#endregion
+//#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) {
+	return await trySubmitToRunningOwner({
+		sessionId: options.sessionId,
+		message: promptToDisplayText(options.prompt),
+		prompt: options.prompt,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		outputFormatter: options.outputFormatter,
+		errorEmissionPolicy: options.errorEmissionPolicy,
+		timeoutMs: options.timeoutMs,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		promptRetries: options.promptRetries,
+		waitForCompletion,
+		verbose: options.verbose,
+		sessionOptions: options.sessionOptions
+	});
+}
+async function runSessionQueueOwner(options) {
+	const lease = await tryAcquireQueueOwnerLease(options.sessionId);
+	if (!lease) return;
+	const sessionRecord = await resolveSessionRecord(options.sessionId);
+	let owner;
+	let heartbeatTimer;
+	const sharedClient = new AcpClient({
+		agentCommand: sessionRecord.agentCommand,
+		cwd: absolutePath(sessionRecord.cwd),
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		sessionOptions: mergeSessionOptions(options.sessionOptions, sessionOptionsFromRecord(sessionRecord))
+	});
+	const ttlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
+	const maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth ?? 16));
+	const taskPollTimeoutMs = ttlMs === 0 ? void 0 : ttlMs;
+	const initialTaskPollTimeoutMs = taskPollTimeoutMs == null ? void 0 : Math.max(taskPollTimeoutMs, 1e3);
+	const turnController = new QueueOwnerTurnController({
+		withTimeout: async (run, timeoutMs) => await withTimeout(run(), timeoutMs),
+		setSessionModeFallback: async (modeId, timeoutMs) => {
+			await runSessionSetModeDirect({
+				sessionRecordId: options.sessionId,
+				modeId,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				terminal: options.terminal,
+				timeoutMs,
+				verbose: options.verbose
+			});
+		},
+		setSessionModelFallback: async (modelId, timeoutMs) => {
+			await runSessionSetModelDirect({
+				sessionRecordId: options.sessionId,
+				modelId,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				terminal: options.terminal,
+				timeoutMs,
+				verbose: options.verbose
+			});
+		},
+		setSessionConfigOptionFallback: async (configId, value, timeoutMs) => {
+			return (await runSessionSetConfigOptionDirect({
+				sessionRecordId: options.sessionId,
+				configId,
+				value,
+				mcpServers: options.mcpServers,
+				nonInteractivePermissions: options.nonInteractivePermissions,
+				authCredentials: options.authCredentials,
+				authPolicy: options.authPolicy,
+				terminal: options.terminal,
+				timeoutMs,
+				verbose: options.verbose
+			})).response;
+		}
+	});
+	const applyPendingCancel = async () => {
+		return await turnController.applyPendingCancel();
+	};
+	const scheduleApplyPendingCancel = () => {
+		applyPendingCancel().catch((error) => {
+			if (options.verbose) process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
+		});
+	};
+	const setActiveController = (controller) => {
+		turnController.setActiveController(controller);
+		scheduleApplyPendingCancel();
+	};
+	const clearActiveController = () => {
+		turnController.clearActiveController();
+	};
+	const closeActiveBackendSession = async (timeoutMs) => {
+		const latestRecord = await resolveSessionRecord(options.sessionId);
+		if (!sharedClient.supportsCloseSession()) return false;
+		await withTimeout(sharedClient.closeSession(latestRecord.acpSessionId), timeoutMs);
+		return true;
+	};
+	const runPromptTurn = async (run) => {
+		turnController.beginTurn();
+		try {
+			return await run();
+		} finally {
+			turnController.endTurn();
+		}
+	};
+	try {
+		owner = await SessionQueueOwner.start(lease, {
+			cancelPrompt: async () => {
+				if (!await turnController.requestCancel()) return false;
+				await applyPendingCancel();
+				return true;
+			},
+			closeSession: async (timeoutMs) => await closeActiveBackendSession(timeoutMs),
+			setSessionMode: async (modeId, timeoutMs) => {
+				await turnController.setSessionMode(modeId, timeoutMs);
+			},
+			setSessionModel: async (modelId, timeoutMs) => {
+				await turnController.setSessionModel(modelId, timeoutMs);
+			},
+			setSessionConfigOption: async (configId, value, timeoutMs) => {
+				return await turnController.setSessionConfigOption(configId, value, timeoutMs);
+			}
+		}, {
+			maxQueueDepth,
+			onQueueDepthChanged: (queueDepth) => {
+				setPerfGauge("queue.owner.depth", queueDepth);
+				refreshQueueOwnerLease(lease, { queueDepth }).catch(() => {});
+			}
+		});
+		if (options.verbose) process.stderr.write(`[acpx] queue owner ready for session ${options.sessionId} (ttlMs=${ttlMs}, maxQueueDepth=${maxQueueDepth})\n`);
+		await refreshQueueOwnerLease(lease, { queueDepth: owner.queueDepth() }).catch(() => {});
+		heartbeatTimer = setInterval(() => {
+			refreshQueueOwnerLease(lease, { queueDepth: owner?.queueDepth() ?? 0 }).catch(() => {});
+		}, QUEUE_OWNER_HEARTBEAT_INTERVAL_MS);
+		let isFirstTask = true;
+		while (true) {
+			const pollTimeoutMs = isFirstTask ? initialTaskPollTimeoutMs : taskPollTimeoutMs;
+			const task = await owner.nextTask(pollTimeoutMs);
+			if (!task) break;
+			isFirstTask = false;
+			await runPromptTurn(async () => {
+				try {
+					await runQueuedTask(options.sessionId, task, {
+						sharedClient,
+						verbose: options.verbose,
+						mcpServers: options.mcpServers,
+						nonInteractivePermissions: options.nonInteractivePermissions,
+						authCredentials: options.authCredentials,
+						authPolicy: options.authPolicy,
+						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+						promptRetries: task.promptRetries ?? 0,
+						sessionOptions: options.sessionOptions,
+						onClientAvailable: setActiveController,
+						onClientClosed: clearActiveController,
+						onPromptActive: async () => {
+							turnController.markPromptActive();
+							await applyPendingCancel();
+						}
+					});
+				} finally {
+					checkpointPerfMetricsCapture();
+				}
+			});
+		}
+	} finally {
+		if (heartbeatTimer) clearInterval(heartbeatTimer);
+		turnController.beginClosing();
+		if (owner) await owner.close();
+		await sharedClient.close().catch(() => {});
+		try {
+			const record = await resolveSessionRecord(options.sessionId);
+			applyLifecycleSnapshotToRecord(record, sharedClient.getAgentLifecycleSnapshot());
+			await writeSessionRecord(record);
+		} catch {}
+		await releaseQueueOwnerLease(lease);
+		if (options.verbose) process.stderr.write(`[acpx] queue owner stopped for session ${options.sessionId}\n`);
+	}
+}
+async function sendSession(options) {
+	const waitForCompletion = options.waitForCompletion !== false;
+	const queuedToOwner = await submitToRunningOwner(options, waitForCompletion);
+	if (queuedToOwner) return queuedToOwner;
+	spawnQueueOwnerProcess(queueOwnerRuntimeOptionsFromSend(options));
+	for (let attempt = 0; attempt < QUEUE_OWNER_STARTUP_MAX_ATTEMPTS; attempt += 1) {
+		const queued = await submitToRunningOwner(options, waitForCompletion);
+		if (queued) return queued;
+		await waitMs(50);
+	}
+	throw new Error(`Session queue owner failed to start for session ${options.sessionId}`);
+}
+//#endregion
+//#region src/session/session.ts
+var session_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_HISTORY_LIMIT: () => 20,
+	DEFAULT_QUEUE_OWNER_TTL_MS: () => DEFAULT_QUEUE_OWNER_TTL_MS,
+	InterruptedError: () => InterruptedError,
+	TimeoutError: () => TimeoutError,
+	cancelSessionPrompt: () => cancelSessionPrompt,
+	closeSession: () => closeSession,
+	createSession: () => createSession,
+	createSessionWithClient: () => createSessionWithClient,
+	ensureSession: () => ensureSession,
+	findGitRepositoryRoot: () => findGitRepositoryRoot,
+	findSession: () => findSession,
+	findSessionByDirectoryWalk: () => findSessionByDirectoryWalk,
+	isProcessAlive: () => isProcessAlive,
+	listSessions: () => listSessions,
+	listSessionsForAgent: () => listSessionsForAgent,
+	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
+	pruneSessions: () => pruneSessions,
+	runOnce: () => runOnce,
+	runQueuedTask: () => runQueuedTask,
+	runSessionQueueOwner: () => runSessionQueueOwner,
+	sendSession: () => sendSession,
+	sendSessionDirect: () => sendSessionDirect,
+	setSessionConfigOption: () => setSessionConfigOption,
+	setSessionMode: () => setSessionMode,
+	setSessionModel: () => setSessionModel
+});
+//#endregion
+//#region src/acp/jsonrpc-error.ts
+const OUTPUT_ERROR_JSONRPC_CODES = {
+	NO_SESSION: -32002,
+	TIMEOUT: -32070,
+	PERMISSION_DENIED: -32071,
+	PERMISSION_PROMPT_UNAVAILABLE: -32072,
+	RUNTIME: -32603,
+	USAGE: -32602
+};
+function hasValidAcpError(acp) {
+	return Boolean(acp && Number.isFinite(acp.code) && typeof acp.message === "string" && acp.message.trim().length > 0);
+}
+function buildFallbackData(params) {
+	const data = {
+		acpxCode: params.outputCode,
+		detailCode: params.detailCode,
+		origin: params.origin,
+		retryable: params.retryable,
+		timestamp: params.timestamp,
+		sessionId: params.sessionId
+	};
+	for (const [key, value] of Object.entries(data)) if (value === void 0) delete data[key];
+	return data;
+}
+function mergeAcpErrorData(acpData, fallbackData) {
+	if (Object.keys(fallbackData).length === 0) return acpData;
+	if (acpData === void 0) return fallbackData;
+	if (acpData && typeof acpData === "object" && !Array.isArray(acpData)) return {
+		...fallbackData,
+		...acpData
+	};
+	return acpData;
+}
+function buildErrorObject(params) {
+	const fallbackData = buildFallbackData(params);
+	if (hasValidAcpError(params.acp)) {
+		const data = mergeAcpErrorData(params.acp.data, fallbackData);
+		return {
+			code: params.acp.code,
+			message: params.acp.message,
+			...data !== void 0 ? { data } : {}
+		};
+	}
+	const data = fallbackData;
+	return {
+		code: OUTPUT_ERROR_JSONRPC_CODES[params.outputCode] ?? -32603,
+		message: params.message,
+		...Object.keys(data).length > 0 ? { data } : {}
+	};
+}
+function buildJsonRpcErrorResponse(params) {
+	return {
+		jsonrpc: "2.0",
+		id: params.id ?? null,
+		error: buildErrorObject(params)
+	};
+}
+//#endregion
+//#region src/cli/output/read-suppression.ts
+const SUPPRESSED_READ_OUTPUT = "[read output suppressed]";
+function inferToolKindFromTitle(title) {
+	const normalized = title?.trim().toLowerCase();
+	if (!normalized) return;
+	const head = normalized.split(":", 1)[0]?.trim();
+	if (!head) return;
+	if (head.includes("read") || head.includes("cat") || head.includes("open") || head.includes("view")) return "read";
+}
+function isReadLikeTool(tool) {
+	return tool.kind?.trim().toLowerCase() === "read" || inferToolKindFromTitle(tool.title) === "read";
+}
+//#endregion
+//#region src/cli/output/json-formatter.ts
+const DEFAULT_JSON_SESSION_ID = "unknown";
+function asRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function jsonRpcIdKey(value) {
+	if (typeof value === "string") return `s:${value}`;
+	if (typeof value === "number" && Number.isFinite(value)) return `n:${value}`;
+}
+function sanitizeReadResult(result) {
+	const record = asRecord$1(result);
+	if (!record || typeof record.content !== "string") return result;
+	return {
+		...record,
+		content: SUPPRESSED_READ_OUTPUT
+	};
+}
+function sanitizeToolContent(content) {
+	if (!Array.isArray(content)) return content;
+	return [{
+		type: "content",
+		content: {
+			type: "text",
+			text: SUPPRESSED_READ_OUTPUT
+		}
+	}];
+}
+function sanitizeToolMessage(message) {
+	const root = asRecord$1(message);
+	const params = asRecord$1(root?.params);
+	const update = asRecord$1(params?.update);
+	if (!root || !params || !update) return message;
+	return {
+		...root,
+		params: {
+			...params,
+			update: {
+				...update,
+				rawOutput: Object.prototype.hasOwnProperty.call(update, "rawOutput") && update.rawOutput !== void 0 ? { content: SUPPRESSED_READ_OUTPUT } : update.rawOutput,
+				content: Object.prototype.hasOwnProperty.call(update, "content") && update.content !== void 0 ? sanitizeToolContent(update.content) : update.content
+			}
+		}
+	};
+}
+var JsonOutputFormatter = class {
+	stdout;
+	suppressReads;
+	sessionId;
+	requestMethodById = /* @__PURE__ */ new Map();
+	toolStateById = /* @__PURE__ */ new Map();
+	constructor(stdout, suppressReads, context) {
+		this.stdout = stdout;
+		this.suppressReads = suppressReads;
+		this.sessionId = context?.sessionId?.trim() || DEFAULT_JSON_SESSION_ID;
+	}
+	setContext(context) {
+		this.sessionId = context.sessionId?.trim() || this.sessionId || DEFAULT_JSON_SESSION_ID;
+	}
+	onAcpMessage(message) {
+		this.stdout.write(`${JSON.stringify(this.sanitizeMessage(message))}\n`);
+	}
+	sanitizeMessage(message) {
+		if (!this.suppressReads) return message;
+		const sanitizedResponse = this.sanitizeReadResponse(message);
+		if (sanitizedResponse !== message) return sanitizedResponse;
+		const sanitizedToolMessage = this.sanitizeReadToolMessage(message);
+		if (sanitizedToolMessage !== message) return sanitizedToolMessage;
+		this.trackRequestMethod(message);
+		return message;
+	}
+	trackRequestMethod(message) {
+		const candidate = message;
+		if (typeof candidate.method !== "string") return;
+		const idKey = jsonRpcIdKey(candidate.id);
+		if (!idKey) return;
+		this.requestMethodById.set(idKey, candidate.method);
+	}
+	sanitizeReadResponse(message) {
+		const candidate = message;
+		const idKey = jsonRpcIdKey(candidate.id);
+		if (!idKey || !Object.hasOwn(candidate, "result")) return message;
+		const method = this.requestMethodById.get(idKey);
+		this.requestMethodById.delete(idKey);
+		if (method !== "fs/read_text_file") return message;
+		const root = asRecord$1(message);
+		if (!root) return message;
+		return {
+			...root,
+			result: sanitizeReadResult(candidate.result)
+		};
+	}
+	sanitizeReadToolMessage(message) {
+		const root = asRecord$1(message);
+		if (root?.method !== "session/update") return message;
+		const params = asRecord$1(root.params);
+		const update = asRecord$1(params?.update);
+		if (!params || !update) return message;
+		const sessionUpdate = update.sessionUpdate;
+		if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") return message;
+		const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+		if (!toolCallId) return message;
+		const previous = this.toolStateById.get(toolCallId) ?? {};
+		const current = {
+			title: typeof update.title === "string" ? update.title : previous.title,
+			kind: typeof update.kind === "string" || update.kind === null ? update.kind : previous.kind
+		};
+		this.toolStateById.set(toolCallId, current);
+		if (!isReadLikeTool(current)) return message;
+		return sanitizeToolMessage(message);
+	}
+	onError(params) {
+		this.stdout.write(`${JSON.stringify(buildJsonRpcErrorResponse({
+			outputCode: params.code,
+			detailCode: params.detailCode,
+			origin: params.origin,
+			message: params.message,
+			retryable: params.retryable,
+			timestamp: params.timestamp,
+			sessionId: this.sessionId,
+			acp: params.acp
+		}))}\n`);
+	}
+	onPermissionEscalation() {}
+	flush() {}
+};
+function createJsonOutputFormatter(stdout, suppressReads = false, context) {
+	return new JsonOutputFormatter(stdout, suppressReads, context);
+}
+//#endregion
+//#region src/cli/output/output.ts
+var output_exports = /* @__PURE__ */ __exportAll({
+	createOutputFormatter: () => createOutputFormatter,
+	getTextErrorRemediationHints: () => getTextErrorRemediationHints
+});
+const MAX_THOUGHT_CHARS = 900;
+const MAX_INLINE_CHARS = 220;
+const MAX_OUTPUT_CHARS = 2e3;
+const MAX_OUTPUT_LINES = 28;
+const MAX_LOCATION_ITEMS = 5;
+const OUTPUT_PRIORITY_KEYS = [
+	"stdout",
+	"stderr",
+	"output",
+	"content",
+	"text",
+	"message",
+	"result",
+	"response",
+	"value"
+];
+function asStatus(status) {
+	return status ?? "unknown";
+}
+function isFinalStatus(status) {
+	return status === "completed" || status === "failed";
+}
+function toStatusLabel(status) {
+	switch (status) {
+		case "in_progress": return "running";
+		case "pending": return "pending";
+		case "completed": return "completed";
+		case "failed": return "failed";
+		default: return "running";
+	}
+}
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function extractJsonRpcMethod(message) {
+	return Object.hasOwn(message, "method") ? message.method?.toString() : void 0;
+}
+function collapseWhitespace(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function normalizeLineEndings(value) {
+	return value.replace(/\r\n?/g, "\n");
+}
+function truncate(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	if (maxChars <= 3) return value.slice(0, maxChars);
+	return `${value.slice(0, maxChars - 3)}...`;
+}
+function toInline(value, maxChars = MAX_INLINE_CHARS) {
+	return truncate(collapseWhitespace(value), maxChars);
+}
+function indentBlock(value, prefix) {
+	return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function dedupeStrings(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const value of values) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		result.push(value);
+	}
+	return result;
+}
+function safeJson(value, spacing) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		return JSON.stringify(value, (_key, entry) => {
+			if (typeof entry === "bigint") return `${entry}n`;
+			if (typeof entry === "function") return `[Function ${entry.name || "anonymous"}]`;
+			if (typeof entry === "symbol") return entry.toString();
+			if (entry && typeof entry === "object") {
+				if (seen.has(entry)) return "[Circular]";
+				seen.add(entry);
+			}
+			return entry;
+		}, spacing);
+	} catch {
+		return;
+	}
+}
+function readFirstString(source, keys) {
+	for (const key of keys) {
+		const value = source[key];
+		if (typeof value === "string" && value.trim()) return value.trim();
+	}
+}
+function readFirstFiniteNumber(source, keys) {
+	for (const key of keys) {
+		const value = source[key];
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+	}
+}
+function formatMetadataNumber(value) {
+	return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(8)));
+}
+function readFirstStringArray(source, keys) {
+	for (const key of keys) {
+		const value = source[key];
+		if (!Array.isArray(value)) continue;
+		const entries = value.map((entry) => typeof entry === "string" ? entry.trim() : "").filter((entry) => entry.length > 0);
+		if (entries.length > 0) return entries;
+	}
+}
+function formatDisjunction(values) {
+	if (values.length <= 1) return values[0] ?? "";
+	if (values.length === 2) return `${values[0]} or ${values[1]}`;
+	return `${values.slice(0, -1).join(", ")}, or ${values.at(-1)}`;
+}
+function parseAuthMethodIdsFromMessage(message) {
+	const methods = [];
+	const methodListMatch = message.match(/auth methods \[([^\]]+)\]/iu);
+	if (methodListMatch) methods.push(...methodListMatch[1].split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+	const singleMethodMatch = message.match(/auth method ([\w.-]+)/iu);
+	if (singleMethodMatch) methods.push(singleMethodMatch[1]);
+	return dedupeStrings(methods);
+}
+function parseAuthMethodIdsFromAcpData(data) {
+	const record = asRecord(data);
+	if (!record) return [];
+	const methodIds = [];
+	if (typeof record.methodId === "string" && record.methodId.trim().length > 0) methodIds.push(record.methodId.trim());
+	if (Array.isArray(record.methods)) for (const entry of record.methods) {
+		if (typeof entry === "string" && entry.trim().length > 0) {
+			methodIds.push(entry.trim());
+			continue;
+		}
+		const id = asRecord(entry)?.id;
+		if (typeof id === "string" && id.trim().length > 0) methodIds.push(id.trim());
+	}
+	return dedupeStrings(methodIds);
+}
+function renderAuthRequiredHint(params) {
+	const methodIds = dedupeStrings([...parseAuthMethodIdsFromAcpData(params.acp?.data), ...parseAuthMethodIdsFromMessage(params.message)]);
+	if (methodIds.length === 0) return "hint: run `acpx config show` to locate the active config, then add the required credential under `auth` and retry.";
+	return `hint: run \`acpx config show\` to locate the active config, then add ${formatDisjunction(methodIds.map((methodId) => `\`auth.${methodId}\``))} and retry.`;
+}
+function getTextErrorRemediationHints(params) {
+	const lowerMessage = params.message.toLowerCase();
+	if (params.detailCode === "AUTH_REQUIRED") return [renderAuthRequiredHint(params)];
+	if (params.code === "TIMEOUT") return ["hint: increase `--timeout <seconds>` for long-running prompts, or check whether the agent/provider is stalled."];
+	if (params.code === "NO_SESSION") {
+		if (lowerMessage.includes("create one:")) return [];
+		return ["hint: the saved ACP session is missing or stale; start a fresh session with `acpx <agent> sessions new`, then retry."];
+	}
+	if (lowerMessage.includes("does not support session/load")) return ["hint: this adapter cannot resume saved ACP sessions; create a fresh one with `acpx <agent> sessions new` instead of reusing `--resume-session`."];
+	if (lowerMessage.includes("failed to resume acp session") || lowerMessage.includes("session/load")) return ["hint: rerun with `--verbose` to capture the ACP load failure details.", "hint: if you do not need the old backend session, start a fresh one with `acpx <agent> sessions new` and retry."];
+	if (/\b429\b/u.test(params.message) || lowerMessage.includes("rate limit") || lowerMessage.includes("quota exceeded")) return ["hint: the provider appears rate-limited; retry later, switch model, or check provider quota/billing."];
+	if (lowerMessage.includes("model not found") || lowerMessage.includes("unknown model") || lowerMessage.includes("invalid model")) return ["hint: check the configured model name for this agent, then retry with `--model <model>` or `sessions set-model <model>`."];
+	if (lowerMessage.includes("session/set_mode") || lowerMessage.includes("session/set_model") || lowerMessage.includes("session/set_config_option")) return ["hint: rerun with `--verbose` to capture the ACP method/error details before retrying."];
+	if (params.origin === "acp" && params.code === "RUNTIME" && (params.acp?.code === -32602 || params.acp?.code === -32603 || lowerMessage.includes("internal error"))) return ["hint: rerun with `--verbose` to capture the underlying ACP error details."];
+	return [];
+}
+function summarizeToolInput(rawInput) {
+	if (rawInput == null) return;
+	if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") return toInline(String(rawInput));
+	const record = asRecord(rawInput);
+	if (record) {
+		const command = readFirstString(record, [
+			"command",
+			"cmd",
+			"program"
+		]);
+		const args = readFirstStringArray(record, ["args", "arguments"]);
+		if (command) return toInline([command, ...args ?? []].join(" "));
+		const location = readFirstString(record, [
+			"path",
+			"file",
+			"filePath",
+			"filepath",
+			"target",
+			"uri",
+			"url"
+		]);
+		if (location) return toInline(location);
+		const query = readFirstString(record, [
+			"query",
+			"pattern",
+			"text",
+			"search"
+		]);
+		if (query) return toInline(query);
+	}
+	const json = safeJson(rawInput, 0);
+	return json ? toInline(json) : void 0;
+}
+function formatLocations(locations) {
+	if (!locations || locations.length === 0) return;
+	const unique = /* @__PURE__ */ new Set();
+	for (const location of locations) {
+		const path = location.path?.trim();
+		if (!path) continue;
+		const line = typeof location.line === "number" && Number.isFinite(location.line) ? `:${Math.max(1, Math.trunc(location.line))}` : "";
+		unique.add(`${path}${line}`);
+	}
+	const items = [...unique];
+	if (items.length === 0) return;
+	const visible = items.slice(0, MAX_LOCATION_ITEMS);
+	const hidden = items.length - visible.length;
+	if (hidden <= 0) return visible.join(", ");
+	return `${visible.join(", ")}, +${hidden} more`;
+}
+function summarizeDiff(path, oldText, newText) {
+	const oldLines = oldText ? oldText.split("\n").length : 0;
+	const delta = newText.split("\n").length - oldLines;
+	if (delta === 0) return `diff ${path} (line count unchanged)`;
+	return `diff ${path} (${`${delta > 0 ? "+" : ""}${delta}`} lines)`;
+}
+function textFromContentBlock(content) {
+	switch (content.type) {
+		case "text": return content.text;
+		case "resource_link": return content.title ?? content.name ?? content.uri;
+		case "resource": {
+			if ("text" in content.resource && typeof content.resource.text === "string") return content.resource.text;
+			const uri = content.resource.uri;
+			const mimeType = content.resource.mimeType;
+			return `[resource] ${uri}${mimeType ? ` (${mimeType})` : ""}`;
+		}
+		case "image": return `[image] ${content.mimeType}`;
+		case "audio": return `[audio] ${content.mimeType}`;
+		default: return;
+	}
+}
+function summarizeToolContent(content) {
+	if (!content || content.length === 0) return;
+	const fragments = [];
+	for (const entry of content) {
+		if (entry.type === "content") {
+			const text = textFromContentBlock(entry.content);
+			if (text && text.trim()) fragments.push(text.trimEnd());
+			continue;
+		}
+		if (entry.type === "diff") {
+			fragments.push(summarizeDiff(entry.path, entry.oldText, entry.newText));
+			continue;
+		}
+		if (entry.type === "terminal") fragments.push(`[terminal] ${entry.terminalId}`);
+	}
+	const unique = dedupeStrings(fragments.map((fragment) => fragment.trim()).filter((fragment) => fragment.length > 0));
+	if (unique.length === 0) return;
+	return unique.join("\n\n");
+}
+function extractOutputText(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
+	if (value == null) return;
+	if (typeof value === "string") {
+		const trimmed = value.trimEnd();
+		return trimmed.length > 0 ? trimmed : void 0;
+	}
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (depth >= 4) return;
+	if (Array.isArray(value)) {
+		const parts = value.map((entry) => extractOutputText(entry, depth + 1, seen)).filter((entry) => Boolean(entry));
+		if (parts.length === 0) return;
+		return dedupeStrings(parts).join("\n");
+	}
+	const record = asRecord(value);
+	if (!record) return;
+	if (seen.has(record)) return;
+	seen.add(record);
+	const preferred = [];
+	for (const key of OUTPUT_PRIORITY_KEYS) {
+		if (!(key in record)) continue;
+		const extracted = extractOutputText(record[key], depth + 1, seen);
+		if (extracted) preferred.push(extracted);
+	}
+	const uniquePreferred = dedupeStrings(preferred);
+	if (uniquePreferred.length > 0) return uniquePreferred.join("\n");
+	const json = safeJson(record, 2);
+	if (!json || json === "{}") return;
+	return json;
+}
+function summarizeToolOutput(rawOutput, content) {
+	const fragments = dedupeStrings([extractOutputText(rawOutput), summarizeToolContent(content)].map((fragment) => fragment?.trim()).filter((fragment) => Boolean(fragment)));
+	if (fragments.length === 0) return;
+	return fragments.join("\n\n");
+}
+function renderToolOutput(state, suppressReads) {
+	if (suppressReads && isReadLikeTool(state)) return SUPPRESSED_READ_OUTPUT;
+	return summarizeToolOutput(state.rawOutput, state.content);
+}
+function limitOutputBlock(value) {
+	const normalized = value.replace(/\r\n/g, "\n").trim();
+	if (!normalized) return "";
+	const lines = normalized.split("\n");
+	const visible = lines.slice(0, MAX_OUTPUT_LINES);
+	let result = visible.join("\n");
+	if (lines.length > visible.length) {
+		const hidden = lines.length - visible.length;
+		result += `\n... (${hidden} more lines)`;
+	}
+	if (result.length > MAX_OUTPUT_CHARS) result = `${result.slice(0, MAX_OUTPUT_CHARS - 3)}...`;
+	return result;
+}
+var TextOutputFormatter = class {
+	stdout;
+	useColor;
+	suppressReads;
+	toolStates = /* @__PURE__ */ new Map();
+	thoughtBuffer = "";
+	wroteAny = false;
+	atLineStart = true;
+	section = null;
+	constructor(stdout, suppressReads) {
+		this.stdout = stdout;
+		this.useColor = Boolean(stdout.isTTY);
+		this.suppressReads = suppressReads;
+	}
+	setContext(_context) {}
+	onAcpMessage(message) {
+		const notification = extractSessionUpdateNotification(message);
+		if (notification) {
+			this.renderSessionUpdate(notification);
+			return;
+		}
+		const method = extractJsonRpcMethod(message);
+		if (method && method !== "session/prompt" && method !== "session/cancel") {
+			this.onClientOperation({
+				method,
+				status: "running",
+				summary: method,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return;
+		}
+		const stopReason = parsePromptStopReason(message);
+		if (stopReason) {
+			this.renderDone(stopReason);
+			return;
+		}
+		const errorMessage = parseJsonRpcErrorMessage(message);
+		if (errorMessage) this.onError({
+			code: "RUNTIME",
+			origin: "acp",
+			message: errorMessage
+		});
+	}
+	renderSessionUpdate(notification) {
+		const update = notification.update;
+		if (update.sessionUpdate !== "agent_thought_chunk") this.flushThoughtBuffer();
+		switch (update.sessionUpdate) {
+			case "agent_message_chunk":
+				if (update.content.type === "text") this.writeAssistantChunk(update.content.text);
+				return;
+			case "agent_thought_chunk":
+				if (update.content.type === "text") this.thoughtBuffer += update.content.text;
+				return;
+			case "tool_call":
+				this.renderToolUpdate(update);
+				return;
+			case "tool_call_update":
+				this.renderToolUpdate(update);
+				return;
+			case "plan":
+				this.beginSection("plan");
+				this.writeLine(this.bold("[plan]"));
+				for (const entry of update.entries) this.writeLine(`  - [${entry.status}] ${entry.content}`);
+				return;
+			default: return;
+		}
+	}
+	renderDone(stopReason) {
+		this.flushThoughtBuffer();
+		this.beginSection("done");
+		this.writeLine(this.dim(`[done] ${stopReason}`));
+	}
+	onError(params) {
+		this.flushThoughtBuffer();
+		this.beginSection("done");
+		this.writeLine(this.formatAnsi(`[error] ${params.code}: ${params.message}`, "31"));
+		for (const hint of getTextErrorRemediationHints(params)) this.writeLine(this.dim(hint));
+	}
+	onClientOperation(operation) {
+		this.flushThoughtBuffer();
+		this.beginSection("client");
+		const normalizedStatus = operation.status === "completed" ? "completed" : operation.status === "failed" ? "failed" : "in_progress";
+		const statusText = this.colorStatus(operation.status, normalizedStatus);
+		this.writeLine(`${this.bold("[client]")} ${operation.summary} (${statusText})`);
+		if (operation.details && operation.details.trim().length > 0) {
+			this.writeLine("  details:");
+			this.writeLine(indentBlock(operation.details, "    "));
+		}
+	}
+	onPermissionEscalation(event) {
+		this.flushThoughtBuffer();
+		this.beginSection("client");
+		this.writeLine(`${this.bold("[permission]")} ${event.message}`);
+		const details = [
+			`sessionId: ${event.sessionId}`,
+			`toolCallId: ${event.toolCallId}`,
+			event.toolName ? `toolName: ${event.toolName}` : void 0,
+			`toolTitle: ${event.toolTitle}`,
+			event.toolInput !== void 0 ? `toolInput: ${summarizeToolInput(event.toolInput) ?? "(structured input)"}` : void 0,
+			event.toolKind ? `toolKind: ${event.toolKind}` : void 0,
+			event.matchedRule ? `matchedRule: ${event.matchedRule}` : void 0
+		].filter((line) => Boolean(line));
+		this.writeLine(indentBlock(details.join("\n"), "  "));
+	}
+	flush() {
+		this.flushThoughtBuffer();
+		if (!this.atLineStart) this.write("\n");
+	}
+	write(chunk) {
+		if (!chunk) return;
+		this.stdout.write(chunk);
+		this.wroteAny = true;
+		this.atLineStart = chunk.endsWith("\n");
+	}
+	writeLine(line) {
+		this.write(`${line}\n`);
+	}
+	beginSection(next) {
+		if (!this.atLineStart) this.write("\n");
+		if (this.wroteAny) this.write("\n");
+		this.section = next;
+	}
+	writeAssistantChunk(text) {
+		if (!text) return;
+		this.section = "assistant";
+		this.write(text);
+	}
+	flushThoughtBuffer() {
+		const thought = truncate(normalizeLineEndings(this.thoughtBuffer).trim(), MAX_THOUGHT_CHARS);
+		this.thoughtBuffer = "";
+		if (!thought) return;
+		this.beginSection("thought");
+		const [firstLine, ...restLines] = thought.split("\n");
+		this.writeLine(this.dim(`[thinking] ${firstLine}`));
+		for (const line of restLines) this.writeLine(this.dim(`           ${line}`));
+	}
+	renderToolUpdate(update) {
+		const state = this.getOrCreateToolState(update.toolCallId);
+		this.mergeToolState(state, update);
+		const status = asStatus(state.status);
+		if (isFinalStatus(status)) {
+			const signature = this.toolSignature(state);
+			if (signature !== state.finalSignature) {
+				state.finalSignature = signature;
+				this.renderFinalToolState(state, status);
+			}
+			return;
+		}
+		if (state.startedPrinted) return;
+		state.startedPrinted = true;
+		this.renderStartingToolState(state, status);
+	}
+	getOrCreateToolState(toolCallId) {
+		const existing = this.toolStates.get(toolCallId);
+		if (existing) return existing;
+		const created = {
+			id: toolCallId,
+			startedPrinted: false
+		};
+		this.toolStates.set(toolCallId, created);
+		return created;
+	}
+	mergeToolState(state, update) {
+		if (typeof update.title === "string" && update.title.trim().length > 0) state.title = update.title;
+		if (update.status !== void 0) state.status = update.status;
+		if (update.kind !== void 0) state.kind = update.kind;
+		if (update.locations !== void 0) state.locations = update.locations;
+		if (update.rawInput !== void 0) state.rawInput = update.rawInput;
+		if (update.rawOutput !== void 0) state.rawOutput = update.rawOutput;
+		if (update.content !== void 0) state.content = update.content;
+	}
+	toolSignature(state) {
+		const signaturePayload = {
+			title: state.title,
+			status: state.status,
+			kind: state.kind,
+			input: summarizeToolInput(state.rawInput),
+			files: formatLocations(state.locations),
+			output: renderToolOutput(state, this.suppressReads)
+		};
+		return safeJson(signaturePayload, 0) ?? JSON.stringify(signaturePayload);
+	}
+	renderStartingToolState(state, status) {
+		this.beginSection("tool");
+		const title = state.title ?? state.id;
+		const label = status === "pending" ? "pending" : "running";
+		const statusText = this.colorStatus(label, status);
+		this.writeLine(`${this.bold("[tool]")} ${title} (${statusText})`);
+		const input = summarizeToolInput(state.rawInput);
+		if (input) this.writeLine(`  input: ${input}`);
+		const files = formatLocations(state.locations);
+		if (files) this.writeLine(`  files: ${files}`);
+	}
+	renderFinalToolState(state, status) {
+		this.beginSection("tool");
+		const title = state.title ?? state.id;
+		const statusText = this.colorStatus(toStatusLabel(status), status);
+		this.writeLine(`${this.bold("[tool]")} ${title} (${statusText})`);
+		if (state.kind) this.writeLine(`  kind: ${state.kind}`);
+		const input = summarizeToolInput(state.rawInput);
+		if (input) this.writeLine(`  input: ${input}`);
+		const files = formatLocations(state.locations);
+		if (files) this.writeLine(`  files: ${files}`);
+		const output = renderToolOutput(state, this.suppressReads);
+		if (output) {
+			this.writeLine("  output:");
+			this.writeLine(indentBlock(limitOutputBlock(output), "    "));
+		}
+	}
+	formatAnsi(text, code) {
+		if (!this.useColor) return text;
+		return `\u001b[${code}m${text}\u001b[0m`;
+	}
+	bold(text) {
+		return this.formatAnsi(text, "1");
+	}
+	dim(text) {
+		return this.formatAnsi(text, "2");
+	}
+	colorStatus(text, status) {
+		if (!this.useColor) return text;
+		switch (status) {
+			case "completed": return this.formatAnsi(text, "32");
+			case "failed": return this.formatAnsi(text, "31");
+			default: return this.formatAnsi(text, "33");
+		}
+	}
+};
+var QuietOutputFormatter = class {
+	stdout;
+	stderr;
+	chunks = [];
+	flushed = false;
+	metadataFlushed = false;
+	constructor(stdout, stderr) {
+		this.stdout = stdout;
+		this.stderr = stderr;
+	}
+	setContext(_context) {}
+	onAcpMessage(message) {
+		const update = extractSessionUpdateNotification(message);
+		if (update?.update.sessionUpdate === "agent_message_chunk" && update.update.content.type === "text") {
+			this.chunks.push(update.update.content.text);
+			return;
+		}
+		if (parsePromptStopReason(message)) {
+			this.flushBufferedOutput();
+			this.flushMetadata(message);
+		}
+	}
+	onError(_params) {}
+	onPermissionEscalation(_event) {}
+	flush() {}
+	flushBufferedOutput() {
+		if (this.flushed) return;
+		this.flushed = true;
+		const text = this.chunks.join("");
+		this.stdout.write(text.endsWith("\n") ? text : `${text}\n`);
+	}
+	flushMetadata(message) {
+		if (this.metadataFlushed) return;
+		this.metadataFlushed = true;
+		const result = asRecord(message.result);
+		if (!result) return;
+		const usageLine = this.formatUsageLine(asRecord(result.usage));
+		if (usageLine) this.stderr.write(`${usageLine}\n`);
+		const costLine = this.formatCostLine(result.cost);
+		if (costLine) this.stderr.write(`${costLine}\n`);
+	}
+	formatUsageLine(usage) {
+		if (!usage) return;
+		const parts = [];
+		for (const [label, keys] of [
+			["input", ["inputTokens", "input_tokens"]],
+			["output", ["outputTokens", "output_tokens"]],
+			["cache_read", [
+				"cachedReadTokens",
+				"cacheReadInputTokens",
+				"cache_read_input_tokens"
+			]],
+			["cache_write", [
+				"cachedWriteTokens",
+				"cacheCreationInputTokens",
+				"cache_creation_input_tokens"
+			]],
+			["total", ["totalTokens", "total_tokens"]]
+		]) {
+			const value = readFirstFiniteNumber(usage, keys);
+			if (value !== void 0) parts.push(`${label}=${formatMetadataNumber(value)}`);
+		}
+		return parts.length > 0 ? `[acpx] tokens: ${parts.join(" ")}` : void 0;
+	}
+	formatCostLine(cost) {
+		if (typeof cost === "number" && Number.isFinite(cost)) return `[acpx] cost: ${formatMetadataNumber(cost)}`;
+		if (typeof cost === "string" && cost.trim()) return `[acpx] cost: ${cost.trim()}`;
+		const record = asRecord(cost);
+		if (!record) return;
+		const amount = readFirstFiniteNumber(record, [
+			"amount",
+			"value",
+			"total"
+		]);
+		if (amount === void 0) return;
+		const currency = typeof record.currency === "string" && record.currency.trim() ? ` ${record.currency.trim()}` : "";
+		return `[acpx] cost: ${formatMetadataNumber(amount)}${currency}`;
+	}
+};
+function createOutputFormatter(format, options = {}) {
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const suppressReads = options.suppressReads === true;
+	switch (format) {
+		case "text": return new TextOutputFormatter(stdout, suppressReads);
+		case "json": return createJsonOutputFormatter(stdout, suppressReads, options.jsonContext);
+		case "quiet": return new QuietOutputFormatter(stdout, stderr);
+		default: throw new Error("Unsupported output format");
+	}
+}
+//#endregion
+export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll 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-BL9XRWzS.js.map