@tickernelz/paperclip-pro-adapter-utils 2026.925.0

package/node_modules/acpx/dist/output-CjdF5rHk.js

@@ -0,0 +1,4593 @@
+import { $ as getPerfMetricsSnapshot, B as absolutePath, C as mergeSessionOptions, Ct as promptToDisplayText, D as applyLifecycleSnapshotToRecord, Dt as withInterrupt, E as applyConversation, Et as TimeoutError, F as modelStateFromConfigOptions, Ft as isRetryablePromptError, G as listSessions, H as findSession, I as splitCommandLine, It as normalizeOutputError, J as pruneSessions, K as listSessionsForAgent, Lt as extractAcpError, N as assertRequestedModelSupported, Ot as withTimeout, Pt as formatErrorMessage, Q as formatPerfMetric, Qt as QueueProtocolError, S as advertisedModelState, T as sessionOptionsFromRecord, Tt as InterruptedError, U as findSessionByDirectoryWalk, Ut as OUTPUT_ERROR_CODES, V as findGitRepositoryRoot, W as isoNow, Wt as OUTPUT_ERROR_ORIGINS, X as writeSessionRecord, Y as resolveSessionRecord, Zt as QueueConnectionError, _ as createSessionConversation, _t as parseJsonRpcErrorMessage, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as recordSessionUpdate, bt as isPromptInput, c as setCurrentModelId, ct as normalizeRuntimeSessionId, d as setDesiredModelId, dt as sessionBaseDir, et as incrementPerfCounter, f as syncAdvertisedModelState, ft as sessionEventActivePath, g as cloneSessionConversation, gt as isAcpJsonRpcMessage, h as cloneSessionAcpxState, ht as extractSessionUpdateNotification, i as connectAndLoadSession, it as setPerfGauge, k as AcpClient, l as setDesiredConfigOption, m as applyConfigOptionsToState, mt as sessionEventSegmentPath, n as runPromptTurn, nt as recordPerfDuration, o as currentModelIdFromSetModelResponse, p as applyConfigOptionsToRecord, pt as sessionEventLockPath, q as normalizeName, r as withConnectedSession, rt as resetPerfMetrics, s as clearDesiredConfigOption, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModeId, ut as defaultSessionEventLog, v as recordClientOperation, vt as parsePromptStopReason, w as persistSessionOptions, wt as textPrompt, x as trimConversationForRuntime, y as recordPromptSubmission, zt as toAcpErrorPayload } from "./live-checkpoint-ClPCSdrW.js";
+import fs, { mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import { createHash, randomInt, randomUUID } from "node:crypto";
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+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/process-liveness.ts
+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;
+	}
+}
+//#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_SIGTERM_GRACE_MS = 4e3;
+const PROCESS_SIGKILL_GRACE_MS = 1500;
+const PROCESS_POLL_MS = 50;
+const QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
+function parseQueueOwnerRecord(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const record = raw;
+	if (!hasValidQueueOwnerRecordFields(record)) return null;
+	return {
+		pid: record.pid,
+		sessionId: record.sessionId,
+		socketPath: record.socketPath,
+		createdAt: record.createdAt,
+		heartbeatAt: record.heartbeatAt,
+		ownerGeneration: record.ownerGeneration,
+		queueDepth: record.queueDepth,
+		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
+		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
+	};
+}
+function hasValidQueueOwnerRecordFields(record) {
+	return isPositiveInteger(record.pid) && typeof record.sessionId === "string" && typeof record.socketPath === "string" && typeof record.createdAt === "string" && typeof record.heartbeatAt === "string" && isPositiveInteger(record.ownerGeneration) && isNonNegativeInteger(record.queueDepth);
+}
+function isPositiveInteger(value) {
+	return Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+	return Number.isInteger(value) && value >= 0;
+}
+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 retireStaleQueueOwner(sessionId, owner) {
+	if (owner && isProcessAlive(owner.pid)) await terminateProcess(owner.pid);
+	await cleanupStaleQueueOwner(sessionId, owner);
+}
+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;
+	}
+}
+async function terminateProcess(pid) {
+	if (!isProcessAlive(pid)) return false;
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		return false;
+	}
+	if (await waitForProcessExit(pid, PROCESS_SIGTERM_GRACE_MS)) return true;
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch {
+		return false;
+	}
+	await waitForProcessExit(pid, PROCESS_SIGKILL_GRACE_MS);
+	return true;
+}
+async function ensureOwnerIsUsable(sessionId, owner) {
+	const alive = isProcessAlive(owner.pid);
+	const stale = isQueueOwnerHeartbeatStale(owner);
+	if (alive && !stale) return true;
+	await retireStaleQueueOwner(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, mcpConfigOrNowIsoFactory, nowIsoFactory = nowIso) {
+	const { mcpConfigPath, clock } = resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory);
+	const mcpConfigMetadata = createMcpConfigMetadata(mcpConfigPath, readMcpConfigFingerprint(mcpConfigOrNowIsoFactory));
+	await ensureQueueDir();
+	const lockPath = queueLockFilePath(sessionId);
+	const socketPath = queueSocketPath(sessionId);
+	const createdAt = clock();
+	const ownerGeneration = createOwnerGeneration();
+	const payload = JSON.stringify({
+		pid: process.pid,
+		sessionId,
+		socketPath,
+		createdAt,
+		heartbeatAt: createdAt,
+		ownerGeneration,
+		queueDepth: 0,
+		...mcpConfigMetadata
+	}, null, 2);
+	try {
+		await fs$1.writeFile(lockPath, `${payload}\n`, {
+			encoding: "utf8",
+			flag: "wx"
+		});
+		await removeSocketFile(socketPath).catch(() => {});
+		return {
+			sessionId,
+			lockPath,
+			socketPath,
+			createdAt,
+			ownerGeneration,
+			...mcpConfigMetadata
+		};
+	} catch (error) {
+		return await handleLeaseCollision(sessionId, error);
+	}
+}
+function readMcpConfigFingerprint(mcpConfigOrNowIsoFactory) {
+	return typeof mcpConfigOrNowIsoFactory === "object" ? mcpConfigOrNowIsoFactory?.fingerprint : void 0;
+}
+function createMcpConfigMetadata(mcpConfigPath, mcpConfigFingerprint) {
+	return {
+		...mcpConfigPath ? { mcpConfigPath } : {},
+		...mcpConfigFingerprint ? { mcpConfigFingerprint } : {}
+	};
+}
+async function handleLeaseCollision(sessionId, 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)) await retireStaleQueueOwner(sessionId, owner);
+}
+function resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory) {
+	if (typeof mcpConfigOrNowIsoFactory === "string") return {
+		mcpConfigPath: mcpConfigOrNowIsoFactory,
+		clock: nowIsoFactory
+	};
+	if (typeof mcpConfigOrNowIsoFactory === "function") return {
+		mcpConfigPath: void 0,
+		clock: mcpConfigOrNowIsoFactory
+	};
+	if (mcpConfigOrNowIsoFactory) return {
+		mcpConfigPath: mcpConfigOrNowIsoFactory.path,
+		clock: nowIsoFactory
+	};
+	return {
+		mcpConfigPath: void 0,
+		clock: nowIsoFactory
+	};
+}
+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)),
+		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
+		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
+	}, 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) {
+	const record = asRecord$2(value);
+	if (!record) return false;
+	return hasValidPermissionRuleLists(record) && hasValidPermissionDefaultAction(record);
+}
+function hasValidPermissionRuleLists(record) {
+	for (const key of [
+		"autoApprove",
+		"autoDeny",
+		"escalate"
+	]) if (!isOptionalStringList(record[key])) return false;
+	return true;
+}
+function isOptionalStringList(value) {
+	return value == null || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasValidPermissionDefaultAction(record) {
+	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 && hasRequiredPermissionEscalationFields(event) && hasOptionalStringFields(event, [
+		"toolName",
+		"toolKind",
+		"matchedRule"
+	]);
+}
+function hasRequiredPermissionEscalationFields(event) {
+	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";
+}
+function hasOptionalStringFields(record, keys) {
+	return keys.every((key) => record[key] == null || typeof record[key] === "string");
+}
+function parseSessionOptions(value) {
+	if (value == null) return;
+	const record = asRecord$2(value);
+	if (!record) return null;
+	const sessionOptions = {};
+	if (!assignSessionModel(sessionOptions, record.model)) return null;
+	if (!assignSessionAllowedTools(sessionOptions, record.allowedTools)) return null;
+	if (!assignSessionMaxTurns(sessionOptions, record.maxTurns)) return null;
+	if (!assignSessionSystemPrompt(sessionOptions, record.systemPrompt)) return null;
+	if (!assignSessionEnv(sessionOptions, record.env)) return null;
+	return sessionOptions;
+}
+function assignSessionModel(options, value) {
+	if (value == null) return true;
+	if (typeof value !== "string" || value.trim().length === 0) return false;
+	options.model = value;
+	return true;
+}
+function assignSessionAllowedTools(options, value) {
+	if (value == null) return true;
+	if (!Array.isArray(value) || value.some((tool) => typeof tool !== "string")) return false;
+	options.allowedTools = value;
+	return true;
+}
+function assignSessionMaxTurns(options, value) {
+	if (value == null) return true;
+	if (typeof value !== "number" || !Number.isFinite(value)) return false;
+	options.maxTurns = Math.max(1, Math.round(value));
+	return true;
+}
+function assignSessionSystemPrompt(options, value) {
+	if (value == null) return true;
+	if (typeof value === "string") {
+		options.systemPrompt = value;
+		return true;
+	}
+	const systemPrompt = asRecord$2(value);
+	if (!systemPrompt || typeof systemPrompt.append !== "string") return false;
+	options.systemPrompt = { append: systemPrompt.append };
+	return true;
+}
+function assignSessionEnv(options, value) {
+	if (value == null) return true;
+	const env = asRecord$2(value);
+	if (!env) return false;
+	const entries = Object.entries(env);
+	if (entries.some(([, entryValue]) => typeof entryValue !== "string")) return false;
+	options.env = Object.fromEntries(entries);
+	return true;
+}
+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 || typeof request.type !== "string" || typeof request.requestId !== "string") return null;
+	const ownerGeneration = parseOwnerGeneration(request.ownerGeneration);
+	if (ownerGeneration === null) return null;
+	return parseTypedQueueRequest(request, parseQueueRequestContext(request.requestId, ownerGeneration, request.timeoutMs));
+}
+function parseQueueRequestContext(requestId, ownerGeneration, timeoutRaw) {
+	return {
+		requestId,
+		ownerGeneration,
+		timeoutMs: parsePositiveTimeout(timeoutRaw)
+	};
+}
+function parsePositiveTimeout(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
+	return Math.round(value);
+}
+function parseTypedQueueRequest(request, context) {
+	switch (request.type) {
+		case "submit_prompt": return parseSubmitRequest(request, context);
+		case "cancel_prompt": return {
+			type: "cancel_prompt",
+			requestId: context.requestId,
+			ownerGeneration: context.ownerGeneration
+		};
+		case "close_session": return {
+			type: "close_session",
+			...context
+		};
+		case "set_mode": return parseStringFieldRequest(request, context, "set_mode", "modeId");
+		case "set_model": return parseStringFieldRequest(request, context, "set_model", "modelId");
+		case "set_config_option": return parseSetConfigOptionRequest(request, context);
+		default: return null;
+	}
+}
+function parseSubmitRequest(request, context) {
+	const parsed = parseSubmitRequestFields(request);
+	if (!parsed) return null;
+	return {
+		type: "submit_prompt",
+		requestId: context.requestId,
+		ownerGeneration: context.ownerGeneration,
+		message: parsed.message,
+		prompt: parsed.prompt ?? textPrompt(parsed.message),
+		permissionMode: parsed.permissionMode,
+		...parsed.resumePolicy !== void 0 ? { resumePolicy: parsed.resumePolicy } : {},
+		nonInteractivePermissions: parsed.nonInteractivePermissions,
+		...parsed.permissionPolicy !== void 0 ? { permissionPolicy: parsed.permissionPolicy } : {},
+		timeoutMs: context.timeoutMs,
+		...parsed.suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors: parsed.suppressSdkConsoleErrors } : {},
+		...parsed.promptRetries !== void 0 ? { promptRetries: parsed.promptRetries } : {},
+		waitForCompletion: parsed.waitForCompletion,
+		...parsed.sessionOptions !== void 0 ? { sessionOptions: parsed.sessionOptions } : {}
+	};
+}
+function parseSubmitRequestFields(request) {
+	const parsed = {
+		message: typeof request.message === "string" ? request.message : null,
+		prompt: parseOptionalValue(request.prompt, isPromptInput),
+		permissionMode: parseRequiredValue(request.permissionMode, isPermissionMode),
+		resumePolicy: parseOptionalValue(request.resumePolicy, isSessionResumePolicy),
+		nonInteractivePermissions: parseOptionalValue(request.nonInteractivePermissions, isNonInteractivePermissionPolicy),
+		permissionPolicy: parseOptionalValue(request.permissionPolicy, isPermissionPolicy),
+		suppressSdkConsoleErrors: parseOptionalBoolean(request.suppressSdkConsoleErrors),
+		promptRetries: parseNonNegativeInteger(request.promptRetries),
+		waitForCompletion: typeof request.waitForCompletion === "boolean" ? request.waitForCompletion : null,
+		sessionOptions: parseSessionOptions(request.sessionOptions)
+	};
+	if (Object.values(parsed).some((value) => value === null)) return null;
+	return parsed;
+}
+function parseOptionalValue(value, guard) {
+	if (value == null) return;
+	return guard(value) ? value : null;
+}
+function parseRequiredValue(value, guard) {
+	return guard(value) ? value : null;
+}
+function parseOptionalBoolean(value) {
+	if (value == null) return;
+	return typeof value === "boolean" ? value : null;
+}
+function parseStringFieldRequest(request, context, type, field) {
+	const value = parseNonEmptyString(request[field]);
+	if (!value) return null;
+	return {
+		type,
+		...context,
+		[field]: value
+	};
+}
+function parseSetConfigOptionRequest(request, context) {
+	const configId = parseNonEmptyString(request.configId);
+	const value = parseNonEmptyString(request.value);
+	if (!configId || !value) return null;
+	return {
+		type: "set_config_option",
+		...context,
+		configId,
+		value
+	};
+}
+function parseNonEmptyString(value) {
+	if (typeof value !== "string" || value.trim().length === 0) return null;
+	return value;
+}
+function parseSessionSendResult(raw) {
+	const result = asRecord$2(raw);
+	if (!result || !hasValidSessionSendResultCore(result)) return null;
+	const permissionStats = asRecord$2(result.permissionStats);
+	const record = asRecord$2(result.record);
+	if (!permissionStats || !record) return null;
+	if (!hasValidPermissionStats(permissionStats)) return null;
+	if (!hasValidSessionRecordShape(record)) return null;
+	return result;
+}
+function hasValidSessionSendResultCore(result) {
+	return typeof result.stopReason === "string" && typeof result.sessionId === "string" && typeof result.resumed === "boolean";
+}
+function hasValidPermissionStats(permissionStats) {
+	return [
+		"requested",
+		"approved",
+		"denied",
+		"cancelled"
+	].every((key) => typeof permissionStats[key] === "number");
+}
+function hasValidSessionRecordShape(record) {
+	return hasStringFields(record, [
+		"acpxRecordId",
+		"acpSessionId",
+		"agentCommand",
+		"cwd",
+		"createdAt",
+		"lastUsedAt",
+		"updated_at"
+	]) && Array.isArray(record.messages) && typeof record.lastSeq === "number" && Number.isInteger(record.lastSeq) && !!record.eventLog && typeof record.eventLog === "object";
+}
+function hasStringFields(record, keys) {
+	return keys.every((key) => typeof record[key] === "string");
+}
+function parseQueueOwnerMessage(raw) {
+	const message = asRecord$2(raw);
+	if (!message || typeof message.type !== "string" || typeof message.requestId !== "string") return null;
+	const ownerGeneration = parseOwnerGeneration(message.ownerGeneration);
+	if (ownerGeneration === null) return null;
+	return parseTypedQueueOwnerMessage(message, {
+		requestId: message.requestId,
+		ownerGeneration
+	});
+}
+function parseTypedQueueOwnerMessage(message, context) {
+	const parser = queueOwnerMessageParser(message.type);
+	return parser ? parser(message, context) : null;
+}
+const QUEUE_OWNER_MESSAGE_PARSERS = {
+	accepted: (_message, context) => ({
+		type: "accepted",
+		...context
+	}),
+	event: parseEventOwnerMessage,
+	permission_escalation: parsePermissionEscalationOwnerMessage,
+	result: parseResultOwnerMessage,
+	cancel_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "cancel_result", "cancelled"),
+	close_session_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "close_session_result", "closed"),
+	set_mode_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_mode_result", "modeId"),
+	set_model_result: parseSetModelOwnerMessage,
+	set_config_option_result: parseSetConfigOptionOwnerMessage,
+	error: parseErrorOwnerMessage
+};
+function queueOwnerMessageParser(type) {
+	return Object.hasOwn(QUEUE_OWNER_MESSAGE_PARSERS, type) ? QUEUE_OWNER_MESSAGE_PARSERS[type] : void 0;
+}
+function parseEventOwnerMessage(message, context) {
+	if (!isAcpJsonRpcMessage(message.message)) return null;
+	return {
+		type: "event",
+		...context,
+		message: message.message
+	};
+}
+function parsePermissionEscalationOwnerMessage(message, context) {
+	if (!isPermissionEscalationEvent(message.event)) return null;
+	return {
+		type: "permission_escalation",
+		...context,
+		event: message.event
+	};
+}
+function parseResultOwnerMessage(message, context) {
+	const result = parseSessionSendResult(message.result);
+	if (!result) return null;
+	return {
+		type: "result",
+		...context,
+		result
+	};
+}
+function parseBooleanResultOwnerMessage(message, context, type, field) {
+	if (typeof message[field] !== "boolean") return null;
+	return {
+		type,
+		...context,
+		[field]: message[field]
+	};
+}
+function parseStringResultOwnerMessage(message, context, type, field) {
+	if (typeof message[field] !== "string") return null;
+	return {
+		type,
+		...context,
+		[field]: message[field]
+	};
+}
+function parseSetModelOwnerMessage(message, context) {
+	if (typeof message.modelId !== "string") return null;
+	const response = asRecord$2(message.response);
+	if (message.response !== void 0 && (!response || !Array.isArray(response.configOptions))) return null;
+	return {
+		type: "set_model_result",
+		...context,
+		modelId: message.modelId,
+		...response ? { response } : {}
+	};
+}
+function parseSetConfigOptionOwnerMessage(message, context) {
+	const response = asRecord$2(message.response);
+	if (!response || !Array.isArray(response.configOptions)) return null;
+	return {
+		type: "set_config_option_result",
+		...context,
+		response
+	};
+}
+function parseErrorOwnerMessage(message, context) {
+	if (!isValidOwnerErrorCore(message)) return null;
+	const outputAlreadyEmitted = typeof message.outputAlreadyEmitted === "boolean" ? message.outputAlreadyEmitted : void 0;
+	return {
+		type: "error",
+		...context,
+		code: message.code,
+		detailCode: parseNonEmptyString(message.detailCode) ?? void 0,
+		origin: message.origin,
+		message: message.message,
+		retryable: typeof message.retryable === "boolean" ? message.retryable : void 0,
+		acp: toAcpErrorPayload(message.acp),
+		...outputAlreadyEmitted === void 0 ? {} : { outputAlreadyEmitted }
+	};
+}
+function isValidOwnerErrorCore(message) {
+	return typeof message.message === "string" && isOutputErrorCode(message.code) && isOutputErrorOrigin(message.origin);
+}
+//#endregion
+//#region src/cli/queue/ipc-server.ts
+const QUEUE_SOCKET_DRAIN_TIMEOUT_MS = 1e3;
+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 = [];
+	sockets = /* @__PURE__ */ new Set();
+	taskSockets = /* @__PURE__ */ new Set();
+	drainingSockets = /* @__PURE__ */ new Set();
+	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;
+	}
+	beginShutdown() {
+		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();
+		}
+		for (const socket of this.sockets) if (!this.taskSockets.has(socket) && !this.drainingSockets.has(socket)) socket.destroy();
+		this.emitQueueDepth();
+	}
+	async close() {
+		this.beginShutdown();
+		await new Promise((resolve) => {
+			const forceCloseTimer = setTimeout(() => {
+				for (const socket of this.sockets) socket.destroy();
+			}, QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
+			forceCloseTimer.unref();
+			this.server.close(() => {
+				clearTimeout(forceCloseTimer);
+				resolve();
+			});
+		});
+	}
+	async nextTask(timeoutMs) {
+		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) {
+			task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
+			task.close();
+			return false;
+		}
+		const waiter = this.waiters.shift();
+		if (waiter) {
+			waiter(task);
+			return true;
+		}
+		if (this.pending.length >= this.maxQueueDepth) {
+			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 false;
+		}
+		this.pending.push(task);
+		this.emitQueueDepth();
+		return true;
+	}
+	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(() => {
+			this.endSocket(options.socket);
+		});
+	}
+	endSocket(socket) {
+		if (socket.destroyed || this.drainingSockets.has(socket)) return;
+		this.taskSockets.delete(socket);
+		this.drainingSockets.add(socket);
+		socket.end(() => {
+			this.drainingSockets.delete(socket);
+			socket.destroy();
+		});
+	}
+	failRequest(socket, requestId, message, detailCode) {
+		writeQueueMessage(socket, {
+			...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
+			ownerGeneration: this.ownerGeneration
+		});
+		this.endSocket(socket);
+	}
+	parseRequestLine(socket, line) {
+		let parsed;
+		try {
+			parsed = JSON.parse(line);
+		} catch {
+			this.failRequest(socket, "unknown", "Invalid queue request payload", "QUEUE_REQUEST_PAYLOAD_INVALID_JSON");
+			return;
+		}
+		const request = parseQueueRequest(parsed);
+		if (!request) this.failRequest(socket, "unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
+		return request ?? void 0;
+	}
+	rejectStaleOwnerGeneration(socket, request) {
+		if (request.ownerGeneration === void 0 || this.ownerGeneration === void 0 || request.ownerGeneration === this.ownerGeneration) return false;
+		this.failRequest(socket, request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
+		return true;
+	}
+	rejectClosedOwner(socket, request) {
+		if (!this.closed) return false;
+		writeQueueMessage(socket, {
+			...makeQueueOwnerError(request.requestId, "Queue owner is shutting down", "QUEUE_OWNER_CLOSED", { retryable: true }),
+			ownerGeneration: this.ownerGeneration
+		});
+		this.endSocket(socket);
+		return true;
+	}
+	handleControlQueueRequest(socket, request) {
+		if (request.type === "cancel_prompt") {
+			this.handleControlRequest({
+				socket,
+				requestId: request.requestId,
+				run: async () => ({
+					type: "cancel_result",
+					requestId: request.requestId,
+					cancelled: await this.controlHandlers.cancelPrompt()
+				})
+			});
+			return true;
+		}
+		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 true;
+		}
+		return this.handleSessionControlQueueRequest(socket, request);
+	}
+	handleSessionControlQueueRequest(socket, request) {
+		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 true;
+		}
+		if (request.type === "set_model") {
+			this.handleControlRequest({
+				socket,
+				requestId: request.requestId,
+				run: async () => {
+					const response = await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+					return {
+						type: "set_model_result",
+						requestId: request.requestId,
+						modelId: request.modelId,
+						response
+					};
+				}
+			});
+			return true;
+		}
+		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 true;
+		}
+		return false;
+	}
+	enqueuePromptRequest(socket, request) {
+		this.taskSockets.add(socket);
+		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: () => {
+				this.endSocket(socket);
+			}
+		};
+		if (!this.enqueue(task)) return;
+		writeQueueMessage(socket, {
+			type: "accepted",
+			requestId: request.requestId,
+			ownerGeneration: this.ownerGeneration
+		});
+		if (!request.waitForCompletion) task.close();
+	}
+	handleConnection(socket) {
+		this.sockets.add(socket);
+		socket.setEncoding("utf8");
+		socket.once("close", () => {
+			this.sockets.delete(socket);
+			this.taskSockets.delete(socket);
+			this.drainingSockets.delete(socket);
+		});
+		let buffer = "";
+		let handled = false;
+		const processLine = (line) => {
+			if (handled) return;
+			handled = true;
+			const request = this.parseRequestLine(socket, line);
+			if (!request || this.rejectClosedOwner(socket, request) || this.rejectStaleOwnerGeneration(socket, request)) return;
+			if (this.handleControlQueueRequest(socket, request)) return;
+			if (request.type !== "submit_prompt") {
+				this.failRequest(socket, request.requestId, "Invalid queue request", "QUEUE_REQUEST_INVALID");
+				return;
+			}
+			this.enqueuePromptRequest(socket, request);
+		};
+		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 = /* @__PURE__ */ 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 queueConnectionErrorFromOwner(message, outputAlreadyEmitted) {
+	return new QueueConnectionError(message.message, {
+		outputCode: message.code,
+		detailCode: message.detailCode,
+		origin: message.origin ?? "queue",
+		retryable: message.retryable,
+		acp: message.acp,
+		...outputAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
+	});
+}
+function makeMalformedQueueMessageError() {
+	return new QueueProtocolError("Queue owner sent malformed message", {
+		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function emitQueueOwnerError(formatter, policy, sessionId, message) {
+	formatter.setContext({ sessionId });
+	const queueErrorAlreadyEmitted = policy?.queueErrorAlreadyEmitted ?? true;
+	const shouldEmitInFormatter = message.outputAlreadyEmitted !== true || !queueErrorAlreadyEmitted;
+	if (shouldEmitInFormatter) {
+		formatter.onError({
+			code: message.code ?? "RUNTIME",
+			detailCode: message.detailCode,
+			origin: message.origin ?? "queue",
+			message: message.message,
+			retryable: message.retryable,
+			acp: message.acp
+		});
+		formatter.flush();
+	}
+	return queueConnectionErrorFromOwner(message, queueErrorAlreadyEmitted || shouldEmitInFormatter);
+}
+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`);
+	});
+}
+function missingQueueAckError() {
+	return new QueueConnectionError("Queue owner did not acknowledge request", {
+		detailCode: "QUEUE_ACK_MISSING",
+		origin: "queue",
+		retryable: true
+	});
+}
+function unexpectedQueueResponseError() {
+	return new QueueProtocolError("Queue owner returned unexpected response", {
+		detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function handleAcknowledgedSubmitMessage(message, controls, formatter) {
+	if (message.type === "event") {
+		formatter.onAcpMessage(message.message);
+		return;
+	}
+	if (message.type === "permission_escalation") {
+		formatter.onPermissionEscalation(message.event);
+		return;
+	}
+	if (message.type === "result") {
+		formatter.flush();
+		controls.resolve(message.result);
+		return;
+	}
+	controls.reject(unexpectedQueueResponseError());
+}
+function handleSubmitQueueOwnerMessage(message, controls, options) {
+	if (message.type === "error") {
+		controls.reject(emitQueueOwnerError(options.outputFormatter, options.errorEmissionPolicy, options.sessionId, message));
+		return;
+	}
+	if (!controls.state.acknowledged) {
+		controls.reject(missingQueueAckError());
+		return;
+	}
+	handleAcknowledgedSubmitMessage(message, controls, options.outputFormatter);
+}
+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, controls) => {
+			handleSubmitQueueOwnerMessage(message, controls, options);
+		},
+		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 response;
+}
+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;
+}
+function queueOwnerMcpConfigMatches(owner, options) {
+	return owner.mcpConfigPath === options.mcpConfigPath && owner.mcpConfigFingerprint === options.mcpConfigFingerprint;
+}
+function assertQueueOwnerMcpConfigMatches(owner, options) {
+	if (queueOwnerMcpConfigMatches(owner, options)) return;
+	throw new QueueConnectionError("Session queue owner uses a different MCP config; close the session before retrying", {
+		detailCode: "QUEUE_MCP_CONFIG_CONFLICT",
+		origin: "queue",
+		retryable: false
+	});
+}
+async function trySubmitToRunningOwner(options) {
+	const owner = await readQueueOwnerRecord(options.sessionId);
+	if (!owner) return;
+	if (!await ensureOwnerIsUsable(options.sessionId, owner)) return;
+	assertQueueOwnerMcpConfigMatches(owner, options);
+	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;
+	const submitted = await submitSetModelToQueueOwner(owner, modelId, timeoutMs);
+	if (submitted) {
+		if (verbose) process.stderr.write(`[acpx] requested a model config update on owner pid ${owner.pid} for session ${sessionId}\n`);
+		return submitted;
+	}
+	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) {
+	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const models = advertisedModelState(record.acpx);
+		const response = await withTimeout(client.setSessionModel(sessionId, options.modelId, models), options.timeoutMs);
+		applyConfigOptionsToRecord(record, response);
+		setDesiredModelId(record, options.modelId, models?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.modelId));
+		return response;
+	}));
+	return {
+		...toSessionMutationResult(result),
+		response: result.value
+	};
+}
+async function runSessionSetConfigOptionDirect(options) {
+	const result = await withConnectedSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
+		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value), options.timeoutMs);
+		applyConfigOptionsToRecord(record, response);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(response, options.value));
+		} else 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
+const execFileAsync = promisify(execFile);
+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) {
+	const submittedToOwner = await trySetModelOnRunningOwner(options.sessionId, options.modelId, options.timeoutMs, options.verbose);
+	if (submittedToOwner) {
+		const record = await resolveSessionRecord(options.sessionId);
+		applyConfigOptionsToRecord(record, submittedToOwner.response);
+		setDesiredModelId(record, options.modelId, advertisedModelState(record.acpx)?.configId);
+		setCurrentModelId(record, currentModelIdFromSetModelResponse(submittedToOwner.response, options.modelId));
+		await writeSessionRecord(record);
+		return {
+			record,
+			response: submittedToOwner.response,
+			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);
+		const modelConfigId = advertisedModelState(record.acpx)?.configId;
+		applyConfigOptionsToRecord(record, ownerResponse);
+		if (options.configId === modelConfigId) {
+			setDesiredModelId(record, options.value, options.configId);
+			setCurrentModelId(record, currentModelIdFromSetModelResponse(ownerResponse, options.value));
+		} else 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) {
+	try {
+		return splitCommandLine(command).command || void 0;
+	} catch {
+		return;
+	}
+}
+async function isLikelyMatchingProcess(pid, agentCommand) {
+	const expectedToken = firstAgentCommandToken(agentCommand);
+	if (!expectedToken) return false;
+	const argv = await readProcessArgv(pid);
+	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);
+}
+async function readProcessArgv(pid) {
+	const procArgv = await readProcCmdline(pid);
+	if (procArgv) return procArgv;
+	return splitCommandLineLike(process.platform === "win32" ? await readWindowsCommandLine(pid) : await readPosixCommandLine(pid));
+}
+async function readProcCmdline(pid) {
+	try {
+		return (await fs$1.readFile(`/proc/${pid}/cmdline`, "utf8")).split("\0").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	} catch {
+		return;
+	}
+}
+async function readPosixCommandLine(pid) {
+	try {
+		const { stdout } = await execFileAsync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		]);
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function readWindowsCommandLine(pid) {
+	try {
+		const { stdout } = await execFileAsync("powershell.exe", [
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			`(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
+		], { windowsHide: true });
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+function splitCommandLineLike(commandLine) {
+	if (!commandLine) return [];
+	try {
+		const parsed = splitCommandLine(commandLine);
+		return [parsed.command, ...parsed.args];
+	} catch {
+		return commandLine.split(/\s+/u).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	}
+}
+const sessionControlTestInternals = {
+	firstAgentCommandToken,
+	splitCommandLineLike
+};
+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);
+	const createdState = options.resumeSessionId ? await resumeSessionRecordWithClient(client, options, cwd) : await createFreshSessionState(client, options, cwd);
+	const { sessionId, agentSessionId } = createdState;
+	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.running ? lifecycle.pid : void 0,
+		agentStartedAt: lifecycle.startedAt,
+		protocolVersion: client.initializeResult?.protocolVersion,
+		agentCapabilities: client.initializeResult?.agentCapabilities,
+		...createSessionConversation(now),
+		acpx: {}
+	};
+	persistSessionOptions(record, options.sessionOptions);
+	applyCreatedSessionModelState(record, createdState, options.sessionOptions?.model);
+	await writeSessionRecord(record);
+	return record;
+}
+function applyCreatedSessionModelState(record, state, requestedModel) {
+	applyConfigOptionsToRecord(record, state.sessionResult);
+	applyConfigOptionsToRecord(record, state.requestedModelResponse);
+	syncAdvertisedModelState(record, state.requestedModelResponse ? modelStateFromConfigOptions(state.requestedModelResponse.configOptions) : state.sessionModels);
+	if (state.requestedModelApplied) setCurrentModelId(record, currentModelIdFromSetModelResponse(state.requestedModelResponse, requestedModel));
+}
+async function createFreshSessionState(client, options, cwd) {
+	const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
+	const modelApplication = await applyRequestedModelIfAdvertised({
+		client,
+		sessionId: createdSession.sessionId,
+		requestedModel: options.sessionOptions?.model,
+		models: createdSession.models,
+		agentCommand: options.agentCommand,
+		timeoutMs: options.timeoutMs,
+		onWarning: options.onModelWarning
+	});
+	return {
+		sessionId: createdSession.sessionId,
+		agentSessionId: normalizeRuntimeSessionId(createdSession.agentSessionId),
+		sessionResult: createdSession,
+		sessionModels: createdSession.models,
+		requestedModelApplied: modelApplication.applied,
+		requestedModelResponse: modelApplication.response
+	};
+}
+async function resumeSessionRecordWithClient(client, options, cwd) {
+	if (!options.resumeSessionId) throw new Error("resumeSessionId is required");
+	const resumeMethod = client.supportsResumeSession() ? "session/resume" : client.supportsLoadSession() ? "session/load" : void 0;
+	if (!resumeMethod) throw new Error(`Agent command "${options.agentCommand}" does not support session/resume or session/load; cannot resume session ${options.resumeSessionId}`);
+	try {
+		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd) : client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
+		const sessionModels = resumedSession.models;
+		const modelApplication = await applyRequestedModelIfAdvertised({
+			client,
+			sessionId: options.resumeSessionId,
+			requestedModel: options.sessionOptions?.model,
+			models: sessionModels,
+			agentCommand: options.agentCommand,
+			timeoutMs: options.timeoutMs,
+			onWarning: options.onModelWarning
+		});
+		return {
+			sessionId: options.resumeSessionId,
+			agentSessionId: normalizeRuntimeSessionId(resumedSession.agentSessionId),
+			sessionResult: resumedSession,
+			sessionModels,
+			requestedModelApplied: modelApplication.applied,
+			requestedModelResponse: modelApplication.response
+		};
+	} catch (error) {
+		throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
+	}
+}
+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();
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		await writeSessionRecord(record);
+	}
+}
+async function listAgentSessions(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
+	});
+	try {
+		return await withInterrupt(async () => {
+			await withTimeout(client.start(), options.timeoutMs);
+			if (!client.supportsListSessions()) return;
+			const cwd = options.filterCwd ? absolutePath(options.filterCwd) : void 0;
+			const response = await withTimeout(client.listSessions({
+				...cwd ? { cwd } : {},
+				...options.cursor ? { cursor: options.cursor } : {}
+			}), options.timeoutMs);
+			return {
+				_meta: response._meta,
+				source: "agent",
+				sessions: response.sessions,
+				cursor: options.cursor,
+				cwd,
+				nextCursor: response.nextCursor
+			};
+		}, async () => {
+			await client.close();
+		});
+	} 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 payloadHasMetrics(payload) {
+	const metrics = payload.metrics;
+	return [
+		metrics.counters,
+		metrics.gauges,
+		metrics.timings
+	].some((entries) => Object.keys(entries ?? {}).length > 0);
+}
+function appendPerfMetricsPayload(payload) {
+	fs.mkdirSync(path.dirname(captureFilePath), { recursive: true });
+	fs.appendFileSync(captureFilePath, `${JSON.stringify(payload)}\n`, "utf8");
+	captureSequence += 1;
+}
+function writePerfMetricsCapture(reason, resetAfterWrite) {
+	if (!shouldCapture()) return false;
+	const payload = buildPayload(reason);
+	if (!payloadHasMetrics(payload)) return false;
+	try {
+		appendPerfMetricsPayload(payload);
+		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) return 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
+const QUEUE_OWNER_PAYLOAD_FILE_ENV = "ACPX_QUEUE_OWNER_PAYLOAD_FILE";
+const QUEUE_OWNER_PAYLOAD_ENV = "ACPX_QUEUE_OWNER_PAYLOAD";
+function isNonEmptyStringArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
+}
+const NODE_TEST_FLAGS = /* @__PURE__ */ new Set([
+	"--experimental-test-coverage",
+	"--test",
+	"--test-name-pattern",
+	"--test-reporter",
+	"--test-reporter-destination"
+]);
+const NODE_TEST_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+	"--test-name-pattern",
+	"--test-reporter",
+	"--test-reporter-destination"
+]);
+const INSPECTOR_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+	"--inspect",
+	"--inspect-brk",
+	"--inspect-port",
+	"--inspect-publish-uid",
+	"--debug-port"
+]);
+const INSPECTOR_FLAG_PREFIXES = [
+	"--inspect=",
+	"--inspect-brk=",
+	"--inspect-port=",
+	"--inspect-publish-uid=",
+	"--debug-port="
+];
+function classifyExecArgv(value) {
+	if (value === void 0) return "drop";
+	if (NODE_TEST_FLAGS_WITH_VALUE.has(value) || INSPECTOR_FLAGS_WITH_VALUE.has(value)) return "drop-with-value";
+	return dropSingleExecArgv(value) ? "drop" : "keep";
+}
+function dropSingleExecArgv(value) {
+	return NODE_TEST_FLAGS.has(value) || value.startsWith("--test-") || INSPECTOR_FLAG_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
+function sanitizeQueueOwnerExecArgv(execArgv = process.execArgv) {
+	const sanitized = [];
+	for (let index = 0; index < execArgv.length; index += 1) {
+		const value = execArgv[index] ?? "";
+		const decision = classifyExecArgv(value);
+		if (decision === "drop") continue;
+		if (decision === "drop-with-value") {
+			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 (isNonEmptyStringArray(parsed)) 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,
+		...options.mcpConfigPath ? { mcpConfigPath: options.mcpConfigPath } : {},
+		...options.mcpConfigFingerprint ? { mcpConfigFingerprint: options.mcpConfigFingerprint } : {},
+		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 writeQueueOwnerPayloadFile(payload) {
+	const dir = mkdtempSync(path.join(os.tmpdir(), "acpx-queue-owner-"));
+	const payloadPath = path.join(dir, "payload.json");
+	writeFileSync(payloadPath, payload, {
+		encoding: "utf8",
+		flag: "wx",
+		mode: 384
+	});
+	return payloadPath;
+}
+function buildQueueOwnerSpawnOptions(payloadFilePath) {
+	const env = {
+		...process.env,
+		[QUEUE_OWNER_PAYLOAD_FILE_ENV]: payloadFilePath
+	};
+	delete env[QUEUE_OWNER_PAYLOAD_ENV];
+	return {
+		detached: true,
+		stdio: "ignore",
+		env,
+		windowsHide: true
+	};
+}
+function spawnQueueOwnerProcess(options) {
+	const payloadPath = writeQueueOwnerPayloadFile(JSON.stringify(options));
+	spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath)).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 resolveInitialSegmentCount(record, maxSegments) {
+	if (Number.isInteger(record.eventLog.segment_count) && record.eventLog.segment_count > 0) return record.eventLog.segment_count;
+	return await countExistingSegments(record.acpxRecordId, maxSegments) || 1;
+}
+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 = await resolveInitialSegmentCount(record, maxSegments);
+		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 markOutputAlreadyEmitted(error, outputAlreadyEmitted) {
+	if (!outputAlreadyEmitted || !error || typeof error !== "object") return;
+	error.outputAlreadyEmitted = true;
+}
+async function runWithOptionalInterrupt(options) {
+	if (options.handleProcessInterrupts === false) return await options.run();
+	return await withInterrupt(options.run, options.handleInterrupt);
+}
+function attachAcpErrorPayload(error, acp) {
+	if (!acp || !error || typeof error !== "object") return;
+	error.acp = acp;
+}
+function rendersAcpErrors(policy) {
+	return policy?.queueErrorAlreadyEmitted ?? true;
+}
+function normalizedErrorText(value) {
+	return value.trim().toLowerCase();
+}
+function outboundAcpErrorMatches(error, acp) {
+	const errorText = normalizedErrorText(formatErrorMessage(error));
+	const details = acp.data?.details;
+	const candidateText = normalizedErrorText(typeof details === "string" && details.trim().length > 0 ? details : acp.message);
+	return errorText === candidateText || errorText.includes(candidateText);
+}
+var AcpErrorTracker = class {
+	latestInbound;
+	outbound = [];
+	reset() {
+		this.latestInbound = void 0;
+		this.outbound.length = 0;
+	}
+	observe(output, direction, message) {
+		output.onAcpMessage(message);
+		const acp = extractAcpError(message);
+		if (!acp) return;
+		if (direction === "inbound") {
+			this.latestInbound = acp;
+			return;
+		}
+		this.outbound.push(acp);
+	}
+	match(error) {
+		return this.latestInbound ?? this.outbound.findLast((acp) => outboundAcpErrorMatches(error, acp));
+	}
+};
+function toPromptResult(stopReason, sessionId, client) {
+	return {
+		stopReason,
+		sessionId,
+		permissionStats: client.getPermissionStats()
+	};
+}
+function requestedModelId(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function applyConfigOptionResponseToState(state, response) {
+	if (!response?.configOptions) return state;
+	return applyConfigOptionsToState(state, response.configOptions);
+}
+function mergeConnectedModelState(state, connectedState) {
+	if (!connectedState) return state;
+	const nextState = cloneSessionAcpxState(state) ?? {};
+	mergeConnectedAdvertisedModelState(nextState, connectedState);
+	mergeConnectedModelPreferences(nextState, connectedState);
+	return nextState;
+}
+function mergeConnectedAdvertisedModelState(nextState, connectedState) {
+	if (connectedState.config_options !== void 0) nextState.config_options = structuredClone(connectedState.config_options);
+	else delete nextState.config_options;
+	if (connectedState.current_model_id !== void 0) nextState.current_model_id = connectedState.current_model_id;
+	else delete nextState.current_model_id;
+	if (connectedState.available_models) nextState.available_models = [...connectedState.available_models];
+	else delete nextState.available_models;
+	if (connectedState.model_control) nextState.model_control = connectedState.model_control;
+	else delete nextState.model_control;
+}
+function mergeConnectedModelPreferences(nextState, connectedState) {
+	if (connectedState.session_options) nextState.session_options = cloneSessionAcpxState(connectedState)?.session_options;
+	if (connectedState.desired_mode_id !== void 0) nextState.desired_mode_id = connectedState.desired_mode_id;
+	if (connectedState.desired_config_options) nextState.desired_config_options = { ...connectedState.desired_config_options };
+}
+async function applyPromptModelIfAdvertised(params) {
+	const requestedModel = requestedModelId(params.requestedModel);
+	if (!requestedModel) return;
+	const models = advertisedModelState(params.record.acpx);
+	emitModelSupportWarning(assertRequestedModelSupported({
+		requestedModel,
+		models,
+		agentCommand: params.record.agentCommand,
+		context: "apply"
+	}), params.suppressWarnings);
+	if (!models) return;
+	if (params.record.acpx?.current_model_id === requestedModel) {
+		setDesiredModelId(params.record, requestedModel, models.configId);
+		return;
+	}
+	const response = await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, models), params.timeoutMs);
+	applyConfigOptionsToRecord(params.record, response);
+	setDesiredModelId(params.record, requestedModel, models.configId);
+	setCurrentModelId(params.record, currentModelIdFromSetModelResponse(response, requestedModel));
+}
+function emitModelSupportWarning(warning, suppressWarnings) {
+	if (warning && !suppressWarnings) process.stderr.write(`[acpx] warning: ${warning}\n`);
+}
+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");
+	const hasResult = Object.hasOwn(candidate, "result");
+	if (!hasError && !hasResult) return;
+	return {
+		idKey,
+		hasError
+	};
+}
+const SESSION_RECONNECT_METHODS = /* @__PURE__ */ new Set(["session/load", "session/resume"]);
+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;
+		const requestMethod = requestMethodById.get(response.idKey);
+		if (requestMethod && SESSION_RECONNECT_METHODS.has(requestMethod)) failedLoadRequestIds.add(response.idKey);
+	}
+	if (failedLoadRequestIds.size === 0) return messages;
+	return messages.filter((message) => {
+		const request = extractJsonRpcRequestInfo(message);
+		if (request && SESSION_RECONNECT_METHODS.has(request.method) && failedLoadRequestIds.has(request.idKey)) return false;
+		const response = extractJsonRpcResponseInfo(message);
+		if (response && failedLoadRequestIds.has(response.idKey)) return false;
+		return true;
+	});
+}
+function filterBufferedConnectOutput(messages, loadError) {
+	if (loadError == null) return messages;
+	const filteredMessages = new Set(filterRecoverableLoadFallbackOutput(messages.map(({ message }) => message)));
+	return messages.filter(({ message }) => filteredMessages.has(message));
+}
+function emitPromptRetryNotice(params) {
+	if (params.suppressSdkConsoleErrors) return;
+	process.stderr.write(`[acpx] prompt failed (${formatErrorMessage(params.error)}), retrying in ${params.delayMs}ms (attempt ${params.attempt}/${params.maxRetries})\n`);
+}
+function emitConnectPerfMetric(startedAt, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] ${formatPerfMetric("prompt.connect_and_load", Date.now() - startedAt)}\n`);
+}
+function emitPromptPerfMetric(startedAt, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] ${formatPerfMetric("prompt.agent_turn", Date.now() - startedAt)}\n`);
+}
+function emitPromptHookError(error, verbose) {
+	if (!verbose) return;
+	process.stderr.write("[acpx] onPromptActive hook failed: " + formatErrorMessage(error) + "\n");
+}
+function emitPromptDisconnectNotice(snapshot, verbose) {
+	const lastExit = snapshot.lastExit;
+	if (!lastExit?.unexpectedDuringPrompt || !verbose) return;
+	process.stderr.write("[acpx] agent disconnected during prompt (" + lastExit.reason + ", exit=" + lastExit.exitCode + ", signal=" + (lastExit.signal ?? "none") + ")\n");
+}
+function shouldRetryRuntimePrompt(error, attempt, maxRetries, snapshot, hasSideEffects) {
+	if (!shouldRetryPromptAttempt(error, attempt, maxRetries, hasSideEffects)) return false;
+	return snapshot.lastExit?.unexpectedDuringPrompt !== true;
+}
+function shouldRetryPromptAttempt(error, attempt, maxRetries, hasSideEffects) {
+	return attempt < maxRetries && !hasSideEffects() && isRetryablePromptError(error);
+}
+async function waitBeforePromptRetry(error, attempt, maxRetries, suppressSdkConsoleErrors) {
+	const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+	emitPromptRetryNotice({
+		error,
+		delayMs,
+		attempt: attempt + 1,
+		maxRetries,
+		suppressSdkConsoleErrors
+	});
+	await waitMs(delayMs);
+}
+function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatter) {
+	return {
+		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,
+		errorEmissionPolicy: { queueErrorAlreadyEmitted: true },
+		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,
+		handleProcessInterrupts: options.handleProcessInterrupts,
+		client: options.sharedClient
+	};
+}
+function sendQueuedTaskResult(task, result) {
+	if (!task.waitForCompletion) return;
+	task.send({
+		type: "result",
+		requestId: task.requestId,
+		result
+	});
+}
+function sendQueuedTaskError(task, error) {
+	if (!task.waitForCompletion) return;
+	const normalizedError = normalizeOutputError(error, {
+		origin: "runtime",
+		detailCode: "QUEUE_RUNTIME_PROMPT_FAILED"
+	});
+	const alreadyEmitted = error.outputAlreadyEmitted === true;
+	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
+	});
+}
+async function runQueuedTask(sessionRecordId, task, options) {
+	const outputFormatter = task.waitForCompletion ? new QueueTaskOutputFormatter(task) : DISCARD_OUTPUT_FORMATTER;
+	try {
+		sendQueuedTaskResult(task, await runSessionPrompt(buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatter)));
+	} catch (error) {
+		sendQueuedTaskError(task, error);
+		if (error instanceof InterruptedError) throw error;
+	} finally {
+		task.close();
+	}
+}
+async function runSessionPrompt(options) {
+	const stopTotalTimer = startPerfTimer("runtime.prompt.total");
+	const output = options.outputFormatter;
+	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
+	const record = await measurePerf("session.resolve_prompt_record", async () => {
+		return await resolveSessionRecord(options.sessionRecordId);
+	});
+	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;
+	const acpErrors = new AcpErrorTracker();
+	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) => {
+			pendingMessages.push(message);
+			options.onAcpMessage?.(direction, message);
+		},
+		onAcpOutputMessage: (direction, message) => {
+			if (bufferingConnectOutput) {
+				pendingConnectOutputMessages.push({
+					direction,
+					message
+				});
+				return;
+			}
+			acpErrors.observe(output, direction, 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) => {
+			const models = advertisedModelState(acpxState);
+			const response = await client.setSessionModel(activeSessionIdForControl, modelId, models);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			nextState.session_options = {
+				...nextState.session_options,
+				model: modelId
+			};
+			nextState.current_model_id = currentModelIdFromSetModelResponse(response, modelId);
+			clearDesiredConfigOption(nextState, models?.configId);
+			acpxState = nextState;
+			return response;
+		},
+		setSessionConfigOption: async (configId, value) => {
+			const response = await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
+			acpxState = applyConfigOptionResponseToState(acpxState, response);
+			const nextState = cloneSessionAcpxState(acpxState) ?? {};
+			if (configId === modelStateFromConfigOptions(nextState.config_options)?.configId) {
+				nextState.session_options = {
+					...nextState.session_options,
+					model: value
+				};
+				nextState.current_model_id = currentModelIdFromSetModelResponse(response, value);
+				clearDesiredConfigOption(nextState, configId);
+			} else if (configId === "mode") nextState.desired_mode_id = value;
+			else nextState.desired_config_options = {
+				...nextState.desired_config_options,
+				[configId]: value
+			};
+			acpxState = nextState;
+			return response;
+		}
+	};
+	const flushConnectOutput = (loadError) => {
+		bufferingConnectOutput = false;
+		const outputMessages = filterBufferedConnectOutput(pendingConnectOutputMessages, loadError);
+		for (const { direction, message } of outputMessages) acpErrors.observe(output, direction, message);
+		pendingConnectOutputMessages.length = 0;
+	};
+	const connectForPrompt = async () => {
+		const connectStartedAt = Date.now();
+		try {
+			const connected = await measurePerf("runtime.connect_and_load", async () => {
+				return await connectAndLoadSession({
+					client,
+					record,
+					resumePolicy: options.resumePolicy,
+					timeoutMs: options.timeoutMs,
+					verbose: options.verbose,
+					suppressWarnings: options.suppressSdkConsoleErrors,
+					activeController,
+					onClientAvailable: (controller) => {
+						options.onClientAvailable?.(controller);
+						notifiedClientAvailable = true;
+					},
+					onConnectedRecord: (connectedRecord) => {
+						connectedRecord.lastPromptAt = isoNow();
+					},
+					onSessionIdResolved: (sessionId) => {
+						activeSessionIdForControl = sessionId;
+					}
+				});
+			});
+			acpxState = mergeConnectedModelState(acpxState, record.acpx);
+			flushConnectOutput(connected.loadError);
+			emitConnectPerfMetric(connectStartedAt, options.verbose);
+			return connected;
+		} catch (error) {
+			flushConnectOutput();
+			throw error;
+		}
+	};
+	const buildPromptStartedHook = (attempt) => {
+		if (attempt !== 0 || !options.onPromptActive) return;
+		return async () => {
+			try {
+				await options.onPromptActive?.();
+			} catch (error) {
+				emitPromptHookError(error, options.verbose);
+			}
+		};
+	};
+	const runPromptAttempt = async (sessionId, attempt) => {
+		acpErrors.reset();
+		const promptStartedAt = Date.now();
+		const response = await measurePerf("runtime.prompt.agent_turn", async () => {
+			return await runPromptTurn({
+				client,
+				sessionId,
+				prompt: options.prompt,
+				timeoutMs: options.timeoutMs,
+				conversation,
+				promptMessageId,
+				onPromptStarted: buildPromptStartedHook(attempt)
+			});
+		});
+		emitPromptPerfMetric(promptStartedAt, options.verbose);
+		return response;
+	};
+	const handlePromptFailure = async (error, attempt) => {
+		const snapshot = client.getAgentLifecycleSnapshot();
+		if (shouldRetryRuntimePrompt(error, attempt, options.promptRetries ?? 0, snapshot, () => promptTurnHadSideEffects)) {
+			await waitBeforePromptRetry(error, attempt, options.promptRetries ?? 0, options.suppressSdkConsoleErrors);
+			return promptTurnHadSideEffects ? await failRuntimePrompt(error, snapshot) : "retry";
+		}
+		return await failRuntimePrompt(error, snapshot);
+	};
+	const failRuntimePrompt = async (error, snapshot) => {
+		promptTurnActive = false;
+		applyLifecycleSnapshotToRecord(record, snapshot);
+		emitPromptDisconnectNotice(snapshot, options.verbose);
+		const matchedAcpError = acpErrors.match(error);
+		const normalizedError = normalizeOutputError(error, {
+			origin: "runtime",
+			acp: matchedAcpError
+		});
+		await flushPendingMessages(false).catch(() => {});
+		output.flush();
+		record.lastUsedAt = isoNow();
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
+		attachAcpErrorPayload(propagated, normalizedError.acp);
+		propagated.outputAlreadyEmitted = matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted;
+		propagated.normalizedOutputError = normalizedError;
+		throw propagated;
+	};
+	const runPromptWithRetries = async (sessionId) => {
+		promptTurnActive = true;
+		for (let attempt = 0;; attempt++) try {
+			return await runPromptAttempt(sessionId, attempt);
+		} catch (error) {
+			if (await handlePromptFailure(error, attempt) === "retry") continue;
+		}
+	};
+	const savePromptSuccess = async (response) => {
+		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 response;
+	};
+	const runPrompt = async () => {
+		const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
+		await applyPromptModelIfAdvertised({
+			client,
+			sessionId: activeSessionId,
+			requestedModel: sessionOptions?.model,
+			record,
+			timeoutMs: options.timeoutMs,
+			suppressWarnings: options.suppressSdkConsoleErrors
+		});
+		acpxState = cloneSessionAcpxState(record.acpx);
+		output.setContext({ sessionId: record.acpxRecordId });
+		await liveCheckpoint.checkpoint();
+		const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
+		promptTurnActive = false;
+		return {
+			...toPromptResult(response.stopReason, record.acpxRecordId, client),
+			record,
+			resumed,
+			loadError
+		};
+	};
+	const handleInterrupt = async () => {
+		await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		record.lastUsedAt = isoNow();
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		await flushPendingMessages(false).catch(() => {});
+		if (ownClient) await client.close();
+	};
+	try {
+		return await runWithOptionalInterrupt({
+			handleProcessInterrupts: options.handleProcessInterrupts,
+			run: runPrompt,
+			handleInterrupt
+		});
+	} catch (error) {
+		const matchedAcpError = acpErrors.match(error);
+		attachAcpErrorPayload(error, matchedAcpError);
+		markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+		throw error;
+	} finally {
+		if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.total", stopTotalTimer())}\n`);
+		else stopTotalTimer();
+		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;
+	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
+	let promptTurnActive = false;
+	let promptTurnHadSideEffects = false;
+	const acpErrors = new AcpErrorTracker();
+	const client = new AcpClient({
+		agentCommand: options.agentCommand,
+		cwd: absolutePath(options.cwd),
+		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) => {
+			acpErrors.observe(output, direction, 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
+	});
+	const runExecPromptAttempt = async (sessionId) => {
+		acpErrors.reset();
+		return await measurePerf("runtime.exec.prompt", async () => {
+			return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
+		});
+	};
+	const runExecPromptWithRetries = async (sessionId) => {
+		const maxRetries = options.promptRetries ?? 0;
+		promptTurnActive = true;
+		for (let attempt = 0;; attempt++) try {
+			return await runExecPromptAttempt(sessionId);
+		} catch (error) {
+			if (shouldRetryPromptAttempt(error, attempt, maxRetries, () => promptTurnHadSideEffects)) {
+				await waitBeforePromptRetry(error, attempt, maxRetries, options.suppressSdkConsoleErrors);
+				if (!promptTurnHadSideEffects) continue;
+			}
+			promptTurnActive = false;
+			throw error;
+		}
+	};
+	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,
+				onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
+			});
+			output.setContext({ sessionId });
+			const response = await runExecPromptWithRetries(sessionId);
+			promptTurnActive = false;
+			output.flush();
+			return toPromptResult(response.stopReason, sessionId, client);
+		}, async () => {
+			await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
+			await client.close();
+		});
+	} catch (error) {
+		const matchedAcpError = acpErrors.match(error);
+		attachAcpErrorPayload(error, matchedAcpError);
+		markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+		throw error;
+	} finally {
+		await client.close();
+	}
+}
+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,
+		errorEmissionPolicy: options.errorEmissionPolicy,
+		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;
+const QUEUE_OWNER_ACTIVE_TURN_CANCEL_GRACE_MS = 750;
+async function submitToRunningOwner(options, waitForCompletion) {
+	return await trySubmitToRunningOwner({
+		sessionId: options.sessionId,
+		message: promptToDisplayText(options.prompt),
+		prompt: options.prompt,
+		mcpConfigPath: options.mcpConfigPath,
+		mcpConfigFingerprint: options.mcpConfigFingerprint,
+		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
+	});
+}
+function createQueueOwnerSharedClient(options, sessionRecord) {
+	return 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))
+	});
+}
+function createQueueOwnerTurnController(options) {
+	return 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) => {
+			return (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
+			})).response;
+		},
+		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;
+		}
+	});
+}
+function logDeferredCancelFailure(error, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
+}
+function logQueueOwnerReady(params) {
+	if (!params.verbose) return;
+	process.stderr.write(`[acpx] queue owner ready for session ${params.sessionId} (ttlMs=${params.ttlMs}, maxQueueDepth=${params.maxQueueDepth})\n`);
+}
+async function closeQueueOwnerRuntime(params) {
+	if (params.heartbeatTimer) clearInterval(params.heartbeatTimer);
+	params.turnController.beginClosing();
+	await params.sharedClient.close().catch(() => {});
+	await params.owner?.close();
+	await writeQueueOwnerLifecycleSnapshot(params.sessionId, params.sharedClient);
+	await releaseQueueOwnerLease(params.lease);
+	if (params.verbose) process.stderr.write(`[acpx] queue owner stopped for session ${params.sessionId}\n`);
+}
+async function writeQueueOwnerLifecycleSnapshot(sessionId, sharedClient) {
+	try {
+		const record = await resolveSessionRecord(sessionId);
+		applyLifecycleSnapshotToRecord(record, sharedClient.getAgentLifecycleSnapshot());
+		await writeSessionRecord(record);
+	} catch {}
+}
+async function settlesWithin(promise, timeoutMs) {
+	let timer;
+	const timeout = new Promise((resolve) => {
+		timer = setTimeout(() => resolve(false), timeoutMs);
+	});
+	try {
+		return await Promise.race([promise.then(() => true, () => true), timeout]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+}
+function createQueueOwnerShutdownController(params) {
+	let requested = false;
+	let activeTurn;
+	let activeTurnShutdown;
+	let shutdownPromise;
+	const drainActiveTurn = async () => {
+		const turn = activeTurn;
+		if (!turn) return;
+		params.turnController.requestCancel().catch((error) => {
+			logDeferredCancelFailure(error, params.verbose);
+		});
+		if (!await settlesWithin(turn, QUEUE_OWNER_ACTIVE_TURN_CANCEL_GRACE_MS)) await params.sharedClient.close().catch(() => {});
+		await turn.catch(() => {});
+	};
+	const request = () => {
+		requested = true;
+		params.stopHeartbeat();
+		params.getOwner()?.beginShutdown();
+		activeTurnShutdown ??= drainActiveTurn();
+	};
+	return {
+		get requested() {
+			return requested;
+		},
+		request,
+		setActiveTurn: (turn) => {
+			activeTurn = turn;
+		},
+		clearActiveTurn: (turn) => {
+			if (activeTurn === turn) activeTurn = void 0;
+		},
+		shutdown: () => {
+			request();
+			shutdownPromise ??= (async () => {
+				await activeTurnShutdown;
+				await closeQueueOwnerRuntime({
+					lease: params.lease,
+					owner: params.getOwner(),
+					heartbeatTimer: void 0,
+					turnController: params.turnController,
+					sharedClient: params.sharedClient,
+					sessionId: params.sessionId,
+					verbose: params.verbose
+				});
+			})();
+			return shutdownPromise;
+		}
+	};
+}
+function applyRequestedShutdown(owner, shutdown) {
+	if (shutdown.requested) owner.beginShutdown();
+}
+function startQueueOwnerHeartbeat(params) {
+	if (!params.enabled) return;
+	return setInterval(() => {
+		refreshQueueOwnerLease(params.lease, { queueDepth: params.owner.queueDepth() }).catch(() => {});
+	}, QUEUE_OWNER_HEARTBEAT_INTERVAL_MS);
+}
+async function runSessionQueueOwner(options) {
+	const lease = await tryAcquireQueueOwnerLease(options.sessionId, {
+		path: options.mcpConfigPath,
+		fingerprint: options.mcpConfigFingerprint
+	});
+	if (!lease) return;
+	const sessionRecord = await resolveSessionRecord(options.sessionId);
+	let owner;
+	let heartbeatTimer;
+	const sharedClient = createQueueOwnerSharedClient(options, 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 = createQueueOwnerTurnController(options);
+	const applyPendingCancel = async () => {
+		return await turnController.applyPendingCancel();
+	};
+	const scheduleApplyPendingCancel = () => {
+		applyPendingCancel().catch((error) => {
+			logDeferredCancelFailure(error, options.verbose);
+		});
+	};
+	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();
+		}
+	};
+	const shutdown = createQueueOwnerShutdownController({
+		lease,
+		getOwner: () => owner,
+		stopHeartbeat: () => {
+			if (heartbeatTimer) {
+				clearInterval(heartbeatTimer);
+				heartbeatTimer = void 0;
+			}
+		},
+		turnController,
+		sharedClient,
+		sessionId: options.sessionId,
+		verbose: options.verbose
+	});
+	const onSignal = () => {
+		shutdown.request();
+	};
+	process.once("SIGINT", onSignal);
+	process.once("SIGTERM", onSignal);
+	process.once("SIGHUP", onSignal);
+	try {
+		owner = await SessionQueueOwner.start(lease, {
+			cancelPrompt: async () => {
+				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(() => {});
+			}
+		});
+		applyRequestedShutdown(owner, shutdown);
+		logQueueOwnerReady({
+			sessionId: options.sessionId,
+			ttlMs,
+			maxQueueDepth,
+			verbose: options.verbose
+		});
+		await refreshQueueOwnerLease(lease, { queueDepth: owner.queueDepth() }).catch(() => {});
+		heartbeatTimer = startQueueOwnerHeartbeat({
+			enabled: !shutdown.requested,
+			lease,
+			owner
+		});
+		let isFirstTask = true;
+		while (true) {
+			const pollTimeoutMs = isFirstTask ? initialTaskPollTimeoutMs : taskPollTimeoutMs;
+			const task = await owner.nextTask(pollTimeoutMs);
+			if (!task) break;
+			isFirstTask = false;
+			const turnPromise = 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();
+						},
+						handleProcessInterrupts: false
+					});
+				} finally {
+					checkpointPerfMetricsCapture();
+				}
+			});
+			shutdown.setActiveTurn(turnPromise);
+			try {
+				await turnPromise;
+			} finally {
+				shutdown.clearActiveTurn(turnPromise);
+			}
+		}
+	} finally {
+		process.off("SIGINT", onSignal);
+		process.off("SIGTERM", onSignal);
+		process.off("SIGHUP", onSignal);
+		await shutdown.shutdown();
+	}
+}
+async function sendSession(options) {
+	const waitForCompletion = options.waitForCompletion !== false;
+	const queuedToOwner = await submitToRunningOwner(options, waitForCompletion);
+	if (queuedToOwner) return queuedToOwner;
+	spawnQueueOwnerProcess(queueOwnerRuntimeOptionsFromSend(options));
+	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,
+	listAgentSessions: () => listAgentSessions,
+	listSessions: () => listSessions,
+	listSessionsForAgent: () => listSessionsForAgent,
+	mergeConnectedModelState: () => mergeConnectedModelState,
+	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
+	pruneSessions: () => pruneSessions,
+	runOnce: () => runOnce,
+	runQueuedTask: () => runQueuedTask,
+	runSessionQueueOwner: () => runSessionQueueOwner,
+	sendSession: () => sendSession,
+	sendSessionDirect: () => sendSessionDirect,
+	sessionControlTestInternals: () => sessionControlTestInternals,
+	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 ([
+		"read",
+		"cat",
+		"open",
+		"view"
+	].some((needle) => head.includes(needle))) 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: sanitizeToolUpdate(update)
+		}
+	};
+}
+function sanitizeToolUpdate(update) {
+	return {
+		...update,
+		rawOutput: sanitizedRawOutput(update),
+		content: sanitizedContent(update)
+	};
+}
+function sanitizedRawOutput(update) {
+	if (Object.prototype.hasOwnProperty.call(update, "rawOutput") && update.rawOutput !== void 0) return { content: SUPPRESSED_READ_OUTPUT };
+	return update.rawOutput;
+}
+function sanitizedContent(update) {
+	if (Object.prototype.hasOwnProperty.call(update, "content") && update.content !== void 0) return sanitizeToolContent(update.content);
+	return 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) return message;
+		const hasResult = Object.hasOwn(candidate, "result");
+		const hasError = Object.hasOwn(candidate, "error");
+		if (!hasResult && !hasError) return message;
+		const method = this.requestMethodById.get(idKey);
+		this.requestMethodById.delete(idKey);
+		if (method !== "fs/read_text_file" || !hasResult) return message;
+		const root = asRecord$1(message);
+		if (!root) return message;
+		return {
+			...root,
+			result: sanitizeReadResult(candidate.result)
+		};
+	}
+	sanitizeReadToolMessage(message) {
+		const update = this.readToolUpdate(message);
+		if (!update) return message;
+		const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+		if (!toolCallId) return message;
+		const current = this.mergeToolState(toolCallId, update);
+		this.toolStateById.set(toolCallId, current);
+		return isReadLikeTool(current) ? sanitizeToolMessage(message) : message;
+	}
+	readToolUpdate(message) {
+		const root = asRecord$1(message);
+		if (root?.method !== "session/update") return;
+		const params = asRecord$1(root.params);
+		const update = asRecord$1(params?.update);
+		if (!params || !update) return;
+		const sessionUpdate = update.sessionUpdate;
+		if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") return;
+		return update;
+	}
+	mergeToolState(toolCallId, update) {
+		const previous = this.toolStateById.get(toolCallId) ?? {};
+		return {
+			title: typeof update.title === "string" ? update.title : previous.title,
+			kind: typeof update.kind === "string" || update.kind === null ? update.kind : previous.kind
+		};
+	}
+	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 parseJsonRpcErrorSummary(message) {
+	const fallback = parseJsonRpcErrorMessage(message);
+	if (!fallback) return;
+	const details = asRecord(asRecord(message.error)?.data)?.details;
+	return typeof details === "string" && details.trim().length > 0 ? details.trim() : fallback;
+}
+function extractJsonRpcMethod(message) {
+	return Object.hasOwn(message, "method") ? message.method?.toString() : void 0;
+}
+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) {
+		const id = parseAuthMethodIdEntry(entry);
+		if (id) methodIds.push(id);
+	}
+	return dedupeStrings(methodIds);
+}
+function parseAuthMethodIdEntry(entry) {
+	if (typeof entry === "string" && entry.trim().length > 0) return entry.trim();
+	const id = asRecord(entry)?.id;
+	return typeof id === "string" && id.trim().length > 0 ? id.trim() : void 0;
+}
+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") return noSessionHints(lowerMessage);
+	return matchingTextErrorRule(params, lowerMessage)?.hints ?? [];
+}
+const TEXT_ERROR_HINT_RULES = [
+	{
+		matches: (_params, lowerMessage) => isUnsupportedSessionLoadError(lowerMessage),
+		hints: ["hint: this adapter cannot resume saved ACP sessions; create a fresh one with `acpx <agent> sessions new` instead of reusing `--resume-session`."]
+	},
+	{
+		matches: (_params, lowerMessage) => isSessionLoadError(lowerMessage),
+		hints: ["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."]
+	},
+	{
+		matches: (params, lowerMessage) => isRateLimitError(params.message, lowerMessage),
+		hints: ["hint: the provider appears rate-limited; retry later, switch model, or check provider quota/billing."]
+	},
+	{
+		matches: (_params, lowerMessage) => isModelLookupError(lowerMessage),
+		hints: ["hint: check the configured model name for this agent, then retry with `--model <model>` or `sessions set-model <model>`."]
+	},
+	{
+		matches: (_params, lowerMessage) => isSessionConfigMethodError(lowerMessage),
+		hints: ["hint: rerun with `--verbose` to capture the ACP method/error details before retrying."]
+	},
+	{
+		matches: isRuntimeAcpProtocolError,
+		hints: ["hint: rerun with `--verbose` to capture the underlying ACP error details."]
+	}
+];
+function matchingTextErrorRule(params, lowerMessage) {
+	return TEXT_ERROR_HINT_RULES.find((rule) => rule.matches(params, lowerMessage));
+}
+function noSessionHints(lowerMessage) {
+	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."];
+}
+function isUnsupportedSessionLoadError(lowerMessage) {
+	return lowerMessage.includes("does not support session/resume") || lowerMessage.includes("does not support session/load");
+}
+function isSessionLoadError(lowerMessage) {
+	return lowerMessage.includes("failed to resume acp session") || lowerMessage.includes("session/resume") || lowerMessage.includes("session/load");
+}
+function isRateLimitError(message, lowerMessage) {
+	return /\b429\b/u.test(message) || ["rate limit", "quota exceeded"].some((text) => lowerMessage.includes(text));
+}
+function isModelLookupError(lowerMessage) {
+	return [
+		"model not found",
+		"unknown model",
+		"invalid model"
+	].some((text) => lowerMessage.includes(text));
+}
+function isSessionConfigMethodError(lowerMessage) {
+	return [
+		"session/set_mode",
+		"session/set_model",
+		"session/set_config_option"
+	].some((text) => lowerMessage.includes(text));
+}
+function isRuntimeAcpProtocolError(params, lowerMessage) {
+	return params.origin === "acp" && params.code === "RUNTIME" && (params.acp?.code === -32602 || params.acp?.code === -32603 || lowerMessage.includes("internal error"));
+}
+function summarizeToolInput(rawInput) {
+	if (rawInput == null) return;
+	if (isScalarToolInput(rawInput)) return toInline(String(rawInput));
+	const record = asRecord(rawInput);
+	if (record) return summarizeToolInputRecord(record) ?? summarizeToolInputJson(rawInput);
+	return summarizeToolInputJson(rawInput);
+}
+function isScalarToolInput(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function summarizeToolInputRecord(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"
+	]);
+	const query = readFirstString(record, [
+		"query",
+		"pattern",
+		"text",
+		"search"
+	]);
+	return location || query ? toInline(location ?? query ?? "") : void 0;
+}
+function summarizeToolInputJson(rawInput) {
+	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 formatted = formatLocation(location);
+		if (formatted) unique.add(formatted);
+	}
+	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 formatLocation(location) {
+	const path = location.path?.trim();
+	if (!path) return;
+	return `${path}${typeof location.line === "number" && Number.isFinite(location.line) ? `:${Math.max(1, Math.trunc(location.line))}` : ""}`;
+}
+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": return textFromResourceBlock(content);
+		case "image": return `[image] ${content.mimeType}`;
+		case "audio": return `[audio] ${content.mimeType}`;
+		default: return;
+	}
+}
+function textFromResourceBlock(content) {
+	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})` : ""}`;
+}
+function summarizeToolContent(content) {
+	if (!content || content.length === 0) return;
+	const fragments = [];
+	for (const entry of content) {
+		const fragment = summarizeToolContentEntry(entry);
+		if (fragment) fragments.push(fragment);
+	}
+	const unique = dedupeStrings(fragments.map((fragment) => fragment.trim()).filter((fragment) => fragment.length > 0));
+	if (unique.length === 0) return;
+	return unique.join("\n\n");
+}
+function summarizeToolContentEntry(entry) {
+	if (entry.type === "content") {
+		const text = textFromContentBlock(entry.content);
+		return text && text.trim() ? text.trimEnd() : void 0;
+	}
+	if (entry.type === "diff") return summarizeDiff(entry.path, entry.oldText, entry.newText);
+	if (entry.type === "terminal") return `[terminal] ${entry.terminalId}`;
+}
+function extractOutputText(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
+	if (value == null) return;
+	const scalar = extractScalarOutputText(value);
+	if (scalar !== null) return scalar;
+	if (depth >= 4) return;
+	if (Array.isArray(value)) return extractOutputTextArray(value, depth, seen);
+	return extractOutputTextRecord(value, depth, seen);
+}
+function extractOutputTextRecord(value, depth, seen) {
+	const record = asRecord(value);
+	if (!record || seen.has(record)) return;
+	seen.add(record);
+	return extractPreferredOutputText(record, depth, seen) ?? extractJsonOutputText(record);
+}
+function extractScalarOutputText(value) {
+	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);
+	return null;
+}
+function extractOutputTextArray(value, depth, seen) {
+	const parts = value.map((entry) => extractOutputText(entry, depth + 1, seen)).filter((entry) => Boolean(entry));
+	return parts.length > 0 ? dedupeStrings(parts).join("\n") : void 0;
+}
+function extractPreferredOutputText(record, depth, seen) {
+	const uniquePreferred = dedupeStrings(OUTPUT_PRIORITY_KEYS.flatMap((key) => {
+		if (!(key in record)) return [];
+		const extracted = extractOutputText(record[key], depth + 1, seen);
+		return extracted ? [extracted] : [];
+	}));
+	return uniquePreferred.length > 0 ? uniquePreferred.join("\n") : void 0;
+}
+function extractJsonOutputText(record) {
+	const json = safeJson(record, 2);
+	return !json || json === "{}" ? void 0 : 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 = parseJsonRpcErrorSummary(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();
+		this.renderSessionUpdateBody(update);
+	}
+	renderSessionUpdateBody(update) {
+		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.renderPlanUpdate(update.entries);
+				return;
+			default: return;
+		}
+	}
+	renderPlanUpdate(entries) {
+		this.beginSection("plan");
+		this.writeLine(this.bold("[plan]"));
+		for (const entry of entries) this.writeLine(`  - [${entry.status}] ${entry.content}`);
+	}
+	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) {
+		this.mergeToolTitle(state, update.title);
+		this.mergeToolPayloadState(state, update);
+	}
+	mergeToolTitle(state, title) {
+		if (typeof title === "string" && title.trim().length > 0) state.title = title;
+	}
+	mergeToolPayloadState(state, update) {
+		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) {
+		const qualifier = params.detailCode ? `${params.code} ${params.detailCode}` : params.code;
+		const message = preferredAcpErrorDetails(params.acp) ?? params.message;
+		this.stderr.write(`[acpx] error: ${qualifier} ${message.replace(/\r\n?|\n/g, " ")}\n`);
+	}
+	onPermissionEscalation(_event) {}
+	flush() {}
+	flushBufferedOutput() {
+		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) {
+		const scalar = this.formatScalarCostLine(cost);
+		if (scalar) return scalar;
+		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}`;
+	}
+	formatScalarCostLine(cost) {
+		if (typeof cost === "number" && Number.isFinite(cost)) return `[acpx] cost: ${formatMetadataNumber(cost)}`;
+		if (typeof cost === "string" && cost.trim()) return `[acpx] cost: ${cost.trim()}`;
+	}
+};
+function preferredAcpErrorDetails(acp) {
+	const details = asRecord(acp?.data)?.details;
+	return typeof details === "string" && details.trim().length > 0 ? details.trim() : void 0;
+}
+function createOutputFormatter(format, options = {}) {
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	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 g, isProcessAlive as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
+
+//# sourceMappingURL=output-CjdF5rHk.js.map