acpx 0.15.1 → 0.17.0

package/dist/output-8-D6Gd4Z.js

@@ -1,4714 +0,0 @@
-import { $ as formatPerfMetric, B as absolutePath, Bt as extractAcpError, C as sessionOptionsFromRecord, D as AcpClient, Dt as TimeoutError, Et as InterruptedError, F as runTimedExecFile, G as listSessions, H as findSession, Ht as toAcpErrorPayload, I as splitCommandLine, J as pruneSessions, K as listSessionsForAgent, Kt as OUTPUT_ERROR_CODES, Lt as formatErrorMessage, M as modelStateFromConfigOptions, Ot as withInterrupt, Rt as isRetryablePromptError, S as persistSessionOptions, T as applyLifecycleSnapshotToRecord, Tt as textPrompt, U as findSessionByDirectoryWalk, V as findGitRepositoryRoot, W as isoNow, X as writeSessionRecord, Y as resolveSessionRecord, _ as recordPromptSubmission, _t as isAcpJsonRpcMessage, a as applyConfigOptionSelection, at as setPerfGauge, b as advertisedModelState, c as applyRequestedModelIfAdvertised, d as setDesiredModeId, dt as defaultSessionEventLog, en as QueueConnectionError, et as getPerfMetricsSnapshot, f as syncAdvertisedModelState, ft as sessionBaseDir, g as recordClientOperation, gt as extractSessionUpdateNotification, h as createSessionConversation, ht as sessionEventSegmentPath, i as connectAndLoadSession, it as resetPerfMetrics, kt as withTimeout, l as currentModelIdFromSetModelResponse, lt as normalizeRuntimeSessionId, m as cloneSessionConversation, mt as sessionEventLockPath, n as runPromptTurn, nt as measurePerf, o as applyConfigOptionsToRecord, ot as startPerfTimer, p as cloneSessionAcpxState, pt as sessionEventActivePath, q as normalizeName, qt as OUTPUT_ERROR_ORIGINS, r as withConnectedSession, rt as recordPerfDuration, s as applyModelSelection, t as LiveSessionCheckpoint, tn as QueueProtocolError, tt as incrementPerfCounter, u as setCurrentModelId, v as recordSessionUpdate, vt as parseJsonRpcErrorMessage, w as applyConversation, wt as promptToDisplayText, x as mergeSessionOptions, xt as isPromptInput, y as trimConversationForRuntime, yt as parsePromptStopReason, zt as normalizeOutputError } from "./live-checkpoint-sB7dFOYR.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 { spawn } from "node:child_process";
-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();
-	try {
-		await fs$1.mkdir(baseDir, {
-			recursive: true,
-			mode: 448
-		});
-		await fs$1.chmod(baseDir, 448);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to prepare queue directory ${baseDir}: ${message}`, { cause: error });
-	}
-	const socketDir = queueSocketBaseDir();
-	if (socketDir) try {
-		await fs$1.mkdir(socketDir, {
-			recursive: true,
-			mode: 448
-		});
-		await fs$1.chmod(socketDir, 448);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to prepare queue socket directory ${socketDir}: ${message}`, { cause: error });
-	}
-}
-async function removeSocketFile(socketPath) {
-	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" && (result._meta === void 0 || result._meta === null || asRecord$2(result._meta) !== void 0);
-}
-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/request-limit.ts
-function queueRequestByteLimit(raw = process.env.ACPX_QUEUE_MAX_REQUEST_BYTES) {
-	if (raw === void 0 || raw.trim() === "") return;
-	const limit = Number(raw);
-	if (!Number.isSafeInteger(limit) || limit < 0 || !/^\d+$/.test(raw.trim())) throw new Error("ACPX_QUEUE_MAX_REQUEST_BYTES must be a non-negative safe integer; zero is unlimited");
-	return limit || void 0;
-}
-function queueRequestExceedsLimit(line, limit) {
-	return limit !== void 0 && Buffer.byteLength(line, "utf8") > limit;
-}
-function assertQueueRequestSize(line) {
-	const limit = queueRequestByteLimit();
-	if (queueRequestExceedsLimit(line, limit)) throw new QueueProtocolError(`Queue request exceeded ACPX_QUEUE_MAX_REQUEST_BYTES (${limit} bytes); raise or unset the limit`, {
-		detailCode: "QUEUE_REQUEST_TOO_LARGE",
-		origin: "queue",
-		retryable: false
-	});
-}
-//#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;
-	maxRequestBytes;
-	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.maxRequestBytes = queueRequestByteLimit(options.maxRequestBytes?.toString());
-		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 rawLine = buffer.slice(0, index);
-				if (this.rejectOversizedRequest(socket, rawLine)) return;
-				const line = rawLine.trim();
-				buffer = buffer.slice(index + 1);
-				if (line.length > 0) processLine(line);
-				index = buffer.indexOf("\n");
-			}
-			this.rejectOversizedRequest(socket, buffer);
-		});
-		socket.on("error", () => {});
-	}
-	rejectOversizedRequest(socket, line) {
-		if (!queueRequestExceedsLimit(line, this.maxRequestBytes)) return false;
-		socket.destroy();
-		return true;
-	}
-};
-//#endregion
-//#region src/cli/queue/ipc.ts
-const MAX_MESSAGE_BUFFER_SIZE = 10485760;
-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 requestLine = JSON.stringify(options.request);
-	assertQueueRequestSize(requestLine);
-	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(`${requestLine}\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.onQueueAccepted?.();
-			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,
-		replacingConfigOption: options.replacingConfigOption,
-		loadRecord: resolveSessionRecord,
-		saveRecord: writeSessionRecord,
-		mcpServers: options.mcpServers,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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,
-		replacingConfigOption: { key: "model" }
-	}, async ({ client, sessionId, record }) => {
-		const models = advertisedModelState(record.acpx);
-		const response = await withTimeout(client.setSessionModel(sessionId, options.modelId, models), options.timeoutMs);
-		record.acpx = applyModelSelection(record.acpx, options.modelId, response);
-		return response;
-	}));
-	return {
-		...toSessionMutationResult(result),
-		response: result.value
-	};
-}
-async function runSessionSetConfigOptionDirect(options) {
-	const result = await withConnectedSession(buildDirectConnectedSessionOptions({
-		...options,
-		replacingConfigOption: { key: options.configId }
-	}, async ({ client, sessionId, record }) => {
-		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value), options.timeoutMs);
-		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, response);
-		return response;
-	}));
-	return {
-		record: result.record,
-		response: result.value,
-		resumed: result.resumed,
-		loadError: result.loadError
-	};
-}
-//#endregion
-//#region src/cli/session/session-control.ts
-async function cancelSessionPrompt(options) {
-	const cancelled = await tryCancelOnRunningOwner(options);
-	return {
-		sessionId: options.sessionId,
-		cancelled: cancelled === true
-	};
-}
-async function setSessionMode(options) {
-	if (await trySetModeOnRunningOwner(options.sessionId, options.modeId, options.timeoutMs, options.verbose)) {
-		const record = await resolveSessionRecord(options.sessionId);
-		setDesiredModeId(record, options.modeId);
-		await writeSessionRecord(record);
-		return {
-			record,
-			resumed: false
-		};
-	}
-	return await runSessionSetModeDirect({
-		sessionRecordId: options.sessionId,
-		modeId: options.modeId,
-		mcpServers: options.mcpServers,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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);
-		record.acpx = applyModelSelection(record.acpx, options.modelId, submittedToOwner.response);
-		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,
-		fs: options.fs,
-		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);
-		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, ownerResponse);
-		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,
-		fs: options.fs,
-		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 {
-		return (await runTimedExecFile("ps", [
-			"-p",
-			String(pid),
-			"-o",
-			"command="
-		])).trim() || void 0;
-	} catch {
-		return;
-	}
-}
-async function readWindowsCommandLine(pid) {
-	try {
-		return (await runTimedExecFile("powershell.exe", [
-			"-NoProfile",
-			"-NonInteractive",
-			"-Command",
-			`(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
-		], { windowsHide: true })).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,
-		agentArgv: options.agentArgv,
-		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,
-		agentArgv: options.agentArgv,
-		cwd: absolutePath(options.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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,
-		agentArgv: options.agentArgv,
-		cwd: absolutePath(options.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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,
-				fs: options.fs,
-				terminal: options.terminal,
-				timeoutMs: options.timeoutMs,
-				verbose: options.verbose
-			})).record,
-			created: false
-		};
-		return {
-			record: existing,
-			created: false
-		};
-	}
-	return {
-		record: await createSession({
-			agentCommand: options.agentCommand,
-			agentArgv: options.agentArgv,
-			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,
-			fs: options.fs,
-			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,
-		fs: options.fs,
-		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;
-}
-/** Max stderr bytes retained for cold-start diagnostics. */
-const QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES = 4e3;
-function buildQueueOwnerSpawnOptions(payloadFilePath, opts) {
-	const env = {
-		...process.env,
-		[QUEUE_OWNER_PAYLOAD_FILE_ENV]: payloadFilePath
-	};
-	delete env[QUEUE_OWNER_PAYLOAD_ENV];
-	return {
-		detached: true,
-		stdio: opts?.captureStderr === true ? [
-			"ignore",
-			"ignore",
-			"pipe"
-		] : "ignore",
-		env,
-		windowsHide: true
-	};
-}
-function formatQueueOwnerStartupFailure(params) {
-	const parts = [`Session queue owner failed to start for session ${params.sessionId}`];
-	if (params.exit.spawnError) parts.push(`spawn error: ${params.exit.spawnError.message}`);
-	else if (params.exit.exited) {
-		const codePart = params.exit.code === null ? "null" : String(params.exit.code);
-		const signalPart = params.exit.signal ? `, signal ${params.exit.signal}` : "";
-		parts.push(`exited with code ${codePart}${signalPart} before binding its socket`);
-	}
-	const tail = params.logTail.trim();
-	if (tail.length > 0) parts.push(`stderr:\n${tail}`);
-	return parts.join(": ");
-}
-function spawnQueueOwnerProcess(options) {
-	const payloadPath = writeQueueOwnerPayloadFile(JSON.stringify(options));
-	let exited = false;
-	let code = null;
-	let signal = null;
-	let spawnError;
-	let capturing = true;
-	let stderrTail = Buffer.alloc(0);
-	const child = spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath, { captureStderr: true }));
-	const stopStartupCapture = () => {
-		if (!capturing) return;
-		capturing = false;
-		const stderr = child.stderr;
-		if (!stderr) return;
-		stderr.removeAllListeners("data");
-		stderr.on("data", () => {});
-		stderr.resume();
-		stderr.unref();
-	};
-	child.stderr?.on("data", (chunk) => {
-		if (!capturing) return;
-		const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-		const combined = Buffer.concat([stderrTail, buf]);
-		stderrTail = combined.length > 4e3 ? combined.subarray(combined.length - QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES) : combined;
-	});
-	child.stderr?.on("error", () => {});
-	child.on("error", (error) => {
-		spawnError = error;
-	});
-	child.on("close", (exitCode, exitSignal) => {
-		exited = true;
-		code = exitCode;
-		signal = exitSignal;
-		stopStartupCapture();
-	});
-	child.unref();
-	return {
-		pid: child.pid,
-		getExitState: () => ({
-			exited,
-			code,
-			signal,
-			...spawnError ? { spawnError } : {}
-		}),
-		readLogTail: (maxBytes = QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES) => {
-			const start = Math.max(0, stderrTail.length - maxBytes);
-			return stderrTail.subarray(start).toString("utf8");
-		},
-		stopStartupCapture
-	};
-}
-//#endregion
-//#region src/session/events.ts
-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, meta) {
-	return {
-		stopReason,
-		sessionId,
-		permissionStats: client.getPermissionStats(),
-		...meta === void 0 ? {} : { _meta: meta }
-	};
-}
-function requestedModelId(value) {
-	return typeof value === "string" ? value.trim() : "";
-}
-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 };
-	else delete nextState.desired_config_options;
-}
-async function applyPromptModelIfAdvertised(params) {
-	const requestedModel = requestedModelId(params.requestedModel);
-	if (!requestedModel) return;
-	const result = await applyRequestedModelIfAdvertised({
-		client: params.client,
-		sessionId: params.sessionId,
-		requestedModel,
-		models: advertisedModelState(params.record.acpx),
-		agentCommand: params.record.agentCommand,
-		timeoutMs: params.timeoutMs,
-		onWarning: params.suppressWarnings ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
-	});
-	if (result.applied) params.record.acpx = applyModelSelection(params.record.acpx, requestedModel, result.response);
-}
-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");
-		}
-	});
-	let closeClientOnExit = options.client == null;
-	const client = options.client ?? new AcpClient({
-		agentCommand: record.agentCommand,
-		agentArgv: record.agentArgv,
-		cwd: absolutePath(record.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		terminal: options.terminal,
-		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-		verbose: options.verbose,
-		sessionOptions
-	});
-	client.updateRuntimeOptions({
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		fs: options.fs,
-		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 = applyModelSelection(acpxState, modelId, response);
-			return response;
-		},
-		setSessionConfigOption: async (configId, value) => {
-			const modelConfigId = advertisedModelState(acpxState)?.configId;
-			const response = await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
-			acpxState = applyConfigOptionSelection(acpxState, configId, value, response, modelConfigId);
-			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,
-					replacingConfigOption: requestedModelId(options.sessionOptions?.model) ? { key: "model" } : void 0,
-					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) {
-			closeClientOnExit = true;
-			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();
-		const now = isoNow();
-		record.lastUsedAt = now;
-		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: options.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, response._meta),
-			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 (closeClientOnExit) 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 (closeClientOnExit) 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,
-		agentArgv: options.agentArgv,
-		cwd: absolutePath(options.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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`)
-			});
-			for (const configOption of options.configOptions ?? []) await withTimeout(client.setSessionConfigOption(sessionId, configOption.configId, configOption.value), options.timeoutMs);
-			output.setContext({ sessionId });
-			const response = await runExecPromptWithRetries(sessionId);
-			promptTurnActive = false;
-			output.flush();
-			return toPromptResult(response.stopReason, sessionId, client, response._meta);
-		}, 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,
-		fs: options.fs,
-		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, extras) {
-	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,
-		onQueueAccepted: extras?.onQueueAccepted
-	});
-}
-function createQueueOwnerSharedClient(options, sessionRecord) {
-	return new AcpClient({
-		agentCommand: sessionRecord.agentCommand,
-		agentArgv: sessionRecord.agentArgv,
-		cwd: absolutePath(sessionRecord.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		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,
-				fs: options.fs,
-				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,
-				fs: options.fs,
-				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,
-				fs: options.fs,
-				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 queueOwnerExitIsFatal(exit) {
-	return exit.exited && (exit.spawnError !== void 0 || exit.code !== 0 || exit.signal !== null);
-}
-function logQueueOwnerReady(params) {
-	if (!params.verbose) return;
-	process.stderr.write(`[acpx] queue owner ready for session ${params.sessionId} (ttlMs=${params.ttlMs}, maxQueueDepth=${params.maxQueueDepth})\n`);
-}
-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;
-	const owner = spawnQueueOwnerProcess(queueOwnerRuntimeOptionsFromSend(options));
-	const onQueueAccepted = () => {
-		owner.stopStartupCapture();
-	};
-	for (let attempt = 0; attempt < QUEUE_OWNER_STARTUP_MAX_ATTEMPTS; attempt += 1) {
-		const queued = await submitToRunningOwner(options, waitForCompletion, { onQueueAccepted });
-		if (queued) {
-			owner.stopStartupCapture();
-			return queued;
-		}
-		const exit = owner.getExitState();
-		if (queueOwnerExitIsFatal(exit)) {
-			const message = formatQueueOwnerStartupFailure({
-				sessionId: options.sessionId,
-				exit,
-				logTail: owner.readLogTail()
-			});
-			owner.stopStartupCapture();
-			throw new Error(message);
-		}
-		await waitMs(50);
-	}
-	const finalExit = owner.getExitState();
-	const message = formatQueueOwnerStartupFailure({
-		sessionId: options.sessionId,
-		exit: finalExit.exited ? finalExit : {
-			exited: false,
-			code: null,
-			signal: null
-		},
-		logTail: owner.readLogTail()
-	});
-	owner.stopStartupCapture();
-	throw new Error(message);
-}
-const queueOwnerRuntimeTestInternals = { queueOwnerExitIsFatal };
-//#endregion
-//#region src/session/session.ts
-var session_exports = /* @__PURE__ */ __exportAll({
-	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,
-	queueOwnerRuntimeTestInternals: () => queueOwnerRuntimeTestInternals,
-	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, 1997)}...`;
-	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-8-D6Gd4Z.js.map