acpx 0.16.0 → 0.17.0

package/dist/ipc-D3akHMEq.js

@@ -0,0 +1,3350 @@
+import { n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DU6mhZBL.js";
+import { statSync } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import { statRegularFile, tempFile, withTempFile } from "@openclaw/fs-safe/advanced";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { root } from "@openclaw/fs-safe";
+import { z } from "zod";
+import { createHash, randomInt, randomUUID } from "node:crypto";
+import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
+import net from "node:net";
+//#region src/errors.ts
+var AcpxOperationalError = class extends Error {
+	outputCode;
+	detailCode;
+	origin;
+	retryable;
+	acp;
+	outputAlreadyEmitted;
+	constructor(message, options) {
+		super(message, options);
+		this.name = new.target.name;
+		this.outputCode = options?.outputCode;
+		this.detailCode = options?.detailCode;
+		this.origin = options?.origin;
+		this.retryable = options?.retryable;
+		this.acp = options?.acp;
+		this.outputAlreadyEmitted = options?.outputAlreadyEmitted;
+	}
+};
+var SessionNotFoundError = class extends AcpxOperationalError {
+	sessionId;
+	constructor(sessionId) {
+		super(`Session not found: ${sessionId}`);
+		this.sessionId = sessionId;
+	}
+};
+var SessionResolutionError = class extends AcpxOperationalError {};
+var AgentSpawnError = class extends AcpxOperationalError {
+	agentCommand;
+	constructor(agentCommand, cause) {
+		const spawnEnoent = (cause instanceof Error ? cause.code : void 0) === "ENOENT";
+		const message = spawnEnoent ? `Failed to spawn agent command: ${agentCommand}. The agent process could not start because a required executable, interpreter, working directory, or other launch path was not found. Check the command, effective PATH, and working directory, or verify the custom agent's configured argv.` : `Failed to spawn agent command: ${agentCommand}`;
+		super(message, {
+			cause: cause instanceof Error ? cause : void 0,
+			...spawnEnoent ? { detailCode: "AGENT_SPAWN_ENOENT" } : {}
+		});
+		this.agentCommand = agentCommand;
+	}
+};
+var AgentStartupError = class extends AcpxOperationalError {
+	agentCommand;
+	exitCode;
+	signal;
+	stderrSummary;
+	constructor(params) {
+		const exitSummary = `exit=${params.exitCode ?? "null"}, signal=${params.signal ?? "null"}`;
+		const stderrSuffix = typeof params.stderrSummary === "string" && params.stderrSummary.trim().length > 0 ? `: ${params.stderrSummary.trim()}` : "";
+		super(`ACP agent exited before initialize completed (${exitSummary})${stderrSuffix}`, {
+			cause: params.cause instanceof Error ? params.cause : void 0,
+			outputCode: "RUNTIME",
+			detailCode: "AGENT_STARTUP_FAILED",
+			origin: "acp"
+		});
+		this.agentCommand = params.agentCommand;
+		this.exitCode = params.exitCode;
+		this.signal = params.signal;
+		this.stderrSummary = params.stderrSummary?.trim() || void 0;
+	}
+};
+var AgentDisconnectedError = class extends AcpxOperationalError {
+	reason;
+	exitCode;
+	signal;
+	constructor(reason, exitCode, signal, options) {
+		super(`ACP agent disconnected during request (${reason}, exit=${exitCode ?? "null"}, signal=${signal ?? "null"})`, {
+			outputCode: "RUNTIME",
+			detailCode: "AGENT_DISCONNECTED",
+			origin: "acp",
+			...options
+		});
+		this.reason = reason;
+		this.exitCode = exitCode;
+		this.signal = signal;
+	}
+};
+var UnsupportedPromptContentError = class extends AcpxOperationalError {
+	constructor(message) {
+		super(message, {
+			outputCode: "USAGE",
+			detailCode: "UNSUPPORTED_PROMPT_CONTENT",
+			origin: "acp"
+		});
+	}
+};
+var SessionResumeRequiredError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_RESUME_REQUIRED",
+			origin: "acp",
+			retryable: true,
+			...options
+		});
+	}
+};
+var GeminiAcpStartupTimeoutError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "TIMEOUT",
+			detailCode: "GEMINI_ACP_STARTUP_TIMEOUT",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var SessionModeReplayError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_MODE_REPLAY_FAILED",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var SessionModelReplayError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_MODEL_REPLAY_FAILED",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var SessionConfigOptionReplayError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "SESSION_CONFIG_OPTION_REPLAY_FAILED",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var ClaudeAcpSessionCreateTimeoutError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "TIMEOUT",
+			detailCode: "CLAUDE_ACP_SESSION_CREATE_TIMEOUT",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var CopilotAcpUnsupportedError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "COPILOT_ACP_UNSUPPORTED",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var AuthPolicyError = class extends AcpxOperationalError {
+	constructor(message, options) {
+		super(message, {
+			outputCode: "RUNTIME",
+			detailCode: "AUTH_REQUIRED",
+			origin: "acp",
+			...options
+		});
+	}
+};
+var QueueConnectionError = class extends AcpxOperationalError {};
+var QueueProtocolError = class extends AcpxOperationalError {};
+var PermissionDeniedError = class extends AcpxOperationalError {};
+var PermissionPromptUnavailableError = class extends AcpxOperationalError {
+	constructor() {
+		super("Permission prompt unavailable in non-interactive mode");
+	}
+};
+//#endregion
+//#region src/types.ts
+const EXIT_CODES = {
+	SUCCESS: 0,
+	ERROR: 1,
+	USAGE: 2,
+	TIMEOUT: 3,
+	NO_SESSION: 4,
+	PERMISSION_DENIED: 5,
+	INTERRUPTED: 130
+};
+const OUTPUT_FORMATS = [
+	"text",
+	"json",
+	"quiet"
+];
+const PERMISSION_MODES = [
+	"approve-all",
+	"approve-reads",
+	"deny-all"
+];
+const AUTH_POLICIES = ["skip", "fail"];
+const NON_INTERACTIVE_PERMISSION_POLICIES = ["deny", "fail"];
+const PERMISSION_POLICY_ACTIONS = [
+	"approve",
+	"deny",
+	"escalate"
+];
+const OUTPUT_ERROR_CODES = [
+	"NO_SESSION",
+	"TIMEOUT",
+	"PERMISSION_DENIED",
+	"PERMISSION_PROMPT_UNAVAILABLE",
+	"RUNTIME",
+	"USAGE"
+];
+const OUTPUT_ERROR_ORIGINS = [
+	"cli",
+	"runtime",
+	"queue",
+	"acp"
+];
+const SESSION_RECORD_SCHEMA = "acpx.session.v1";
+//#endregion
+//#region src/acp/error-shapes.ts
+const RESOURCE_NOT_FOUND_ACP_CODES = /* @__PURE__ */ new Set([-32001, -32002]);
+function asRecord$5(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function toAcpErrorPayload(value) {
+	const record = asRecord$5(value);
+	if (!record) return;
+	if (typeof record.code !== "number" || !Number.isFinite(record.code)) return;
+	if (typeof record.message !== "string" || record.message.length === 0) return;
+	return {
+		code: record.code,
+		message: record.message,
+		data: record.data
+	};
+}
+function extractAcpErrorInternal(value, depth) {
+	if (depth > 5) return;
+	const direct = toAcpErrorPayload(value);
+	if (direct) return direct;
+	const record = asRecord$5(value);
+	if (!record) return;
+	return extractNestedAcpError(record, depth);
+}
+function extractNestedAcpError(record, depth) {
+	for (const key of [
+		"error",
+		"acp",
+		"cause"
+	]) if (key in record) {
+		const nested = extractAcpErrorInternal(record[key], depth + 1);
+		if (nested) return nested;
+	}
+}
+function formatUnknownErrorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (error && typeof error === "object") {
+		const maybeMessage = error.message;
+		if (typeof maybeMessage === "string" && maybeMessage.length > 0) return maybeMessage;
+		try {
+			return JSON.stringify(error);
+		} catch {}
+	}
+	return String(error);
+}
+const SESSION_NOT_FOUND_PATTERN = /session\s+["'\w-]+\s+not found/i;
+function isSessionNotFoundText(value) {
+	if (typeof value !== "string") return false;
+	const normalized = value.toLowerCase();
+	return normalized.includes("resource_not_found") || normalized.includes("resource not found") || normalized.includes("session not found") || normalized.includes("unknown session") || normalized.includes("invalid session identifier") || SESSION_NOT_FOUND_PATTERN.test(value);
+}
+function hasSessionNotFoundHint(value, depth = 0) {
+	if (depth > 4) return false;
+	if (isSessionNotFoundText(value)) return true;
+	if (Array.isArray(value)) return value.some((entry) => hasSessionNotFoundHint(entry, depth + 1));
+	const record = asRecord$5(value);
+	if (!record) return false;
+	return Object.values(record).some((entry) => hasSessionNotFoundHint(entry, depth + 1));
+}
+function extractAcpError(error) {
+	return extractAcpErrorInternal(error, 0);
+}
+function isAcpResourceNotFoundError(error) {
+	const acp = extractAcpError(error);
+	if (acp && RESOURCE_NOT_FOUND_ACP_CODES.has(acp.code)) return true;
+	if (acp) {
+		if (isSessionNotFoundText(acp.message)) return true;
+		if (hasSessionNotFoundHint(acp.data)) return true;
+	}
+	return isSessionNotFoundText(formatUnknownErrorMessage(error));
+}
+//#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 \0@oxc-project+runtime@0.149.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	}, e = {}, n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o, t = this.e, s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+//#region src/state-files.ts
+async function writePrivateFile(filePath, content, options = {}) {
+	try {
+		var _usingCtx$1 = _usingCtx();
+		const privateDirectory = options.privateDirectory !== false;
+		await fs$1.mkdir(path.dirname(filePath), {
+			recursive: true,
+			mode: privateDirectory ? 448 : void 0
+		});
+		const directory = await fs$1.realpath(path.dirname(filePath));
+		if (privateDirectory && process.platform !== "win32") await fs$1.chmod(directory, 448);
+		const temporary = _usingCtx$1.a(await tempFile({
+			rootDir: directory,
+			prefix: "acpx-write",
+			fileName: "record.json"
+		}));
+		const handle = await fs$1.open(temporary.path, "wx", 384);
+		try {
+			await handle.writeFile(content, "utf8");
+			await handle.chmod(384);
+		} finally {
+			await handle.close();
+		}
+		await fs$1.rename(temporary.path, path.join(directory, path.basename(filePath)));
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		await _usingCtx$1.d();
+	}
+}
+async function writePrivateJsonFile(filePath, value) {
+	await writePrivateFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+//#endregion
+//#region src/session/event-log.ts
+const DEFAULT_EVENT_SEGMENT_MAX_BYTES = 67108864;
+function sessionBaseDir() {
+	return path.join(os.homedir(), ".acpx", "sessions");
+}
+function safeSessionId(sessionId) {
+	return encodeURIComponent(sessionId);
+}
+function sessionEventActivePath(sessionId) {
+	return path.join(sessionBaseDir(), `${safeSessionId(sessionId)}.stream.ndjson`);
+}
+function sessionEventSegmentPath(sessionId, segment) {
+	return path.join(sessionBaseDir(), `${safeSessionId(sessionId)}.stream.${segment}.ndjson`);
+}
+function sessionEventLockPath(sessionId) {
+	return path.join(sessionBaseDir(), `${safeSessionId(sessionId)}.stream.lock`);
+}
+function defaultSessionEventLog(sessionId) {
+	return {
+		active_path: sessionEventActivePath(sessionId),
+		segment_count: 5,
+		max_segment_bytes: DEFAULT_EVENT_SEGMENT_MAX_BYTES,
+		max_segments: 5,
+		last_write_at: void 0,
+		last_write_error: null
+	};
+}
+//#endregion
+//#region src/acp/jsonrpc.ts
+function asRecord$4(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function isAcpMessageObject(value) {
+	return asRecord$4(value) !== null;
+}
+function hasValidId(value) {
+	return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
+}
+function isErrorObject(value) {
+	const record = asRecord$4(value);
+	return !!record && typeof record.code === "number" && Number.isFinite(record.code) && typeof record.message === "string";
+}
+function hasResultOrError(value) {
+	const hasResult = Object.hasOwn(value, "result");
+	const hasError = Object.hasOwn(value, "error");
+	if (hasResult && hasError) return false;
+	if (!hasResult && !hasError) return false;
+	if (hasError && !isErrorObject(value.error)) return false;
+	return true;
+}
+function hasMethod(value) {
+	return typeof value.method === "string" && value.method.length > 0;
+}
+function isJsonRpcRequest(value) {
+	return hasMethod(value) && Object.hasOwn(value, "id") && hasValidId(value.id);
+}
+function isJsonRpcNotificationRecord(value) {
+	return hasMethod(value) && !Object.hasOwn(value, "id");
+}
+function isJsonRpcResponse(value) {
+	if (hasMethod(value) || !Object.hasOwn(value, "id") || !hasValidId(value.id)) return false;
+	return hasResultOrError(value);
+}
+function isAcpJsonRpcMessage(value) {
+	const record = asRecord$4(value);
+	if (!record || record.jsonrpc !== "2.0") return false;
+	return isJsonRpcNotificationRecord(record) || isJsonRpcRequest(record) || isJsonRpcResponse(record);
+}
+function isJsonRpcNotification(message) {
+	return Object.hasOwn(message, "method") && typeof message.method === "string" && !Object.hasOwn(message, "id");
+}
+function isSessionUpdateNotification(message) {
+	return isJsonRpcNotification(message) && message.method === "session/update";
+}
+function extractSessionUpdateNotification(message) {
+	if (!isSessionUpdateNotification(message)) return;
+	const params = asRecord$4(message.params);
+	if (!params) return;
+	const sessionId = typeof params.sessionId === "string" ? params.sessionId : null;
+	if (!sessionId) return;
+	const update = asRecord$4(params.update);
+	if (!update || typeof update.sessionUpdate !== "string") return;
+	return {
+		sessionId,
+		update
+	};
+}
+function parsePromptStopReason(message) {
+	if (!Object.hasOwn(message, "id") || !Object.hasOwn(message, "result")) return;
+	const record = asRecord$4(message.result);
+	if (!record) return;
+	return typeof record.stopReason === "string" ? record.stopReason : void 0;
+}
+function parsePermissionNotice(message) {
+	if (!Object.hasOwn(message, "id") || !Object.hasOwn(message, "result")) return;
+	const notice = asRecord$4(asRecord$4(asRecord$4(message.result)?._meta)?.acpx)?.permissionNotice;
+	return typeof notice === "string" ? notice : void 0;
+}
+function parseJsonRpcErrorMessage(message) {
+	if (!Object.hasOwn(message, "error")) return;
+	const errorRecord = asRecord$4(message.error);
+	if (!errorRecord || typeof errorRecord.message !== "string") return;
+	return errorRecord.message;
+}
+//#endregion
+//#region src/perf-metrics.ts
+const counters = /* @__PURE__ */ new Map();
+const gauges = /* @__PURE__ */ new Map();
+const timings = /* @__PURE__ */ new Map();
+function hrNow() {
+	return process.hrtime.bigint();
+}
+function durationMs(start) {
+	return Number(process.hrtime.bigint() - start) / 1e6;
+}
+function roundMetric(value) {
+	return Number(value.toFixed(3));
+}
+function incrementPerfCounter(name, delta = 1) {
+	counters.set(name, (counters.get(name) ?? 0) + delta);
+}
+function setPerfGauge(name, value) {
+	gauges.set(name, value);
+}
+function recordPerfDuration(name, durationMsValue) {
+	const next = timings.get(name) ?? {
+		count: 0,
+		totalMs: 0,
+		maxMs: 0
+	};
+	next.count += 1;
+	next.totalMs += durationMsValue;
+	next.maxMs = Math.max(next.maxMs, durationMsValue);
+	timings.set(name, next);
+}
+async function measurePerf(name, run) {
+	const startedAt = hrNow();
+	try {
+		return await run();
+	} finally {
+		recordPerfDuration(name, durationMs(startedAt));
+	}
+}
+function startPerfTimer(name) {
+	const startedAt = hrNow();
+	return () => {
+		const elapsedMs = durationMs(startedAt);
+		recordPerfDuration(name, elapsedMs);
+		return elapsedMs;
+	};
+}
+function getPerfMetricsSnapshot() {
+	return {
+		counters: Object.fromEntries(counters.entries()),
+		gauges: Object.fromEntries(gauges.entries()),
+		timings: Object.fromEntries([...timings.entries()].map(([name, bucket]) => [name, {
+			count: bucket.count,
+			totalMs: roundMetric(bucket.totalMs),
+			maxMs: roundMetric(bucket.maxMs)
+		}]))
+	};
+}
+function resetPerfMetrics() {
+	counters.clear();
+	gauges.clear();
+	timings.clear();
+}
+function formatPerfMetric(name, durationMsValue) {
+	return `${name}=${roundMetric(durationMsValue)}ms`;
+}
+//#endregion
+//#region src/session/journal.ts
+const SESSION_JOURNAL_SCHEMA = "acpx.session.journal.v1";
+const sequenceSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+const resultSchema = z.union([z.object({
+	status: z.enum(["completed", "cancelled"]),
+	stopReason: z.string().optional(),
+	_meta: z.record(z.string(), z.unknown()).nullable().optional()
+}), z.object({
+	status: z.literal("failed"),
+	error: z.object({
+		message: z.string(),
+		code: z.string().optional(),
+		detailCode: z.string().optional(),
+		retryable: z.boolean().optional()
+	})
+})]);
+const markerSchema = z.discriminatedUnion("type", [
+	z.object({
+		schema: z.literal(SESSION_JOURNAL_SCHEMA),
+		type: z.literal("segment"),
+		record_id: z.string(),
+		sequence: sequenceSchema,
+		message_sequence: sequenceSchema,
+		request_id: z.string().nullable()
+	}),
+	z.object({
+		schema: z.literal(SESSION_JOURNAL_SCHEMA),
+		type: z.literal("turn_started"),
+		request_id: z.string().min(1)
+	}),
+	z.object({
+		schema: z.literal(SESSION_JOURNAL_SCHEMA),
+		type: z.literal("turn_result"),
+		request_id: z.string().min(1),
+		result: resultSchema
+	})
+]);
+const WATCH_PAGE_BYTES = 1048576;
+function createJournalPage(options = {}) {
+	const maxBytes = options.maxBytes ?? Infinity;
+	if (!(maxBytes > 0)) throw new Error("Session journal page size must be positive");
+	return {
+		events: [],
+		after: options.after ?? -1,
+		bytes: 0,
+		maxBytes
+	};
+}
+function pageFull(page) {
+	return page !== void 0 && page.bytes >= page.maxBytes;
+}
+function eventSink(page, sequence, bytes) {
+	if (!page || sequence <= page.after) return;
+	page.bytes += bytes;
+	return page.events;
+}
+var SessionWatchError = class extends AcpxOperationalError {
+	code;
+	constructor(code, message) {
+		super(message, {
+			outputCode: code.startsWith("WATCH_CURSOR_") ? "USAGE" : "RUNTIME",
+			detailCode: code,
+			origin: "runtime",
+			retryable: false
+		});
+		this.code = code;
+	}
+};
+function corrupt(message) {
+	throw new SessionWatchError("WATCH_JOURNAL_CORRUPT", message);
+}
+function sessionWatchCursor(recordId, sequence) {
+	return Buffer.from(JSON.stringify([recordId, sequence])).toString("base64url");
+}
+function parseCursor(recordId, cursor) {
+	let value;
+	try {
+		value = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+	} catch {
+		throw new SessionWatchError("WATCH_CURSOR_INVALID", "Invalid session watch cursor");
+	}
+	const parsed = z.tuple([z.string(), sequenceSchema]).safeParse(value);
+	if (!parsed.success || sessionWatchCursor(...parsed.data) !== cursor) throw new SessionWatchError("WATCH_CURSOR_INVALID", "Invalid session watch cursor");
+	if (parsed.data[0] !== recordId) throw new SessionWatchError("WATCH_CURSOR_FOREIGN", "Cursor belongs to another session");
+	return parsed.data[1];
+}
+function fileIdentity(stat) {
+	return `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+}
+function emptySegment() {
+	return {
+		offset: 0,
+		pending: Buffer.alloc(0),
+		sequence: 0,
+		messageSequence: 0,
+		requestId: null
+	};
+}
+function retryableSnapshotError(error) {
+	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "not-found" || error.code === "path-mismatch");
+}
+var SessionJournalReader = class {
+	record;
+	states = /* @__PURE__ */ new Map();
+	constructor(record) {
+		this.record = record;
+	}
+	paths() {
+		const paths = [];
+		for (let index = this.record.eventLog.max_segments; index > 0; index -= 1) paths.push(sessionEventSegmentPath(this.record.acpxRecordId, index));
+		paths.push(sessionEventActivePath(this.record.acpxRecordId));
+		return paths;
+	}
+	async openSnapshot(signal) {
+		for (;;) {
+			signal?.throwIfAborted();
+			const segments = [];
+			try {
+				const paths = await this.openPresentSegments(segments);
+				const current = await Promise.all(paths.map((filePath) => statRegularFile(filePath)));
+				const identities = new Map(segments.map((entry) => [entry.filePath, entry.identity]));
+				if (paths.every((filePath, index) => {
+					const entry = current[index];
+					return (entry.missing ? void 0 : fileIdentity(entry.stat)) === identities.get(filePath);
+				})) return segments;
+			} catch (error) {
+				if (!retryableSnapshotError(error)) {
+					await this.closeSnapshot(segments);
+					throw error;
+				}
+			}
+			await this.closeSnapshot(segments);
+			await setTimeout$1(5, void 0, { signal });
+		}
+	}
+	async openPresentSegments(segments) {
+		const paths = this.paths();
+		const present = await Promise.all(paths.map((filePath) => statRegularFile(filePath)));
+		if (present.every((entry) => entry.missing)) return paths;
+		const directory = await root(path.dirname(paths[0]));
+		const results = await Promise.allSettled(paths.filter((_, index) => !present[index].missing).map(async (filePath) => {
+			const opened = await directory.open(path.basename(filePath), {
+				symlinks: "reject",
+				nonBlockingRead: true
+			});
+			return {
+				filePath,
+				opened,
+				identity: fileIdentity(opened.stat)
+			};
+		}));
+		let failure;
+		for (const result of results) if (result.status === "fulfilled") segments.push(result.value);
+		else failure ??= result.reason;
+		if (failure) throw failure;
+		return paths;
+	}
+	async closeSnapshot(segments) {
+		await Promise.all(segments.map(({ opened }) => opened[Symbol.asyncDispose]()));
+	}
+	async readAcpMessages() {
+		const segments = await this.openSnapshot();
+		const messages = [];
+		try {
+			for (const { opened } of segments) {
+				const payload = await opened.handle.readFile("utf8");
+				for (const line of payload.split("\n")) try {
+					const value = JSON.parse(line);
+					if (isAcpJsonRpcMessage(value)) messages.push(value);
+				} catch {}
+			}
+			return messages;
+		} finally {
+			await this.closeSnapshot(segments);
+		}
+	}
+	async readTail() {
+		const segments = await this.openSnapshot();
+		let tail = emptySegment();
+		let active = emptySegment();
+		try {
+			for (const segment of segments.toReversed()) {
+				const state = emptySegment();
+				await this.readSegment(segment.opened.handle, segment.opened.stat.size, state, void 0);
+				if (segment.filePath === sessionEventActivePath(this.record.acpxRecordId)) active = state;
+				if (state.firstSequence !== void 0) {
+					tail = state;
+					break;
+				}
+			}
+			return {
+				sequence: tail.sequence,
+				messageSequence: tail.firstSequence === void 0 ? void 0 : tail.messageSequence,
+				requestId: tail.requestId,
+				activeSize: active.offset,
+				activeAnchored: active.firstSequence !== void 0,
+				activePartial: active.pending.length > 0
+			};
+		} finally {
+			await this.closeSnapshot(segments);
+		}
+	}
+	async read(signal, options) {
+		const page = createJournalPage(options);
+		const segments = await this.openSnapshot(signal);
+		let hasMore = false;
+		let firstSequence;
+		let tail = emptySegment();
+		let active = emptySegment();
+		try {
+			for (const segment of segments) {
+				const state = this.states.get(segment.identity) ?? emptySegment();
+				await this.readSegment(segment.opened.handle, segment.opened.stat.size, state, page, signal);
+				this.states.set(segment.identity, state);
+				if (state.firstSequence !== void 0) {
+					if (firstSequence === void 0) firstSequence = state.firstSequence;
+					else if (state.firstSequence !== tail.sequence) corrupt("Session journal segments are not contiguous");
+					tail = state;
+				}
+				if (segment.filePath === sessionEventActivePath(this.record.acpxRecordId)) active = state;
+				if (pageFull(page)) {
+					hasMore = true;
+					break;
+				}
+			}
+			this.pruneStates(segments);
+			return {
+				events: page.events,
+				hasMore,
+				firstSequence,
+				sequence: tail.sequence,
+				messageSequence: tail.messageSequence,
+				requestId: tail.requestId,
+				activeSize: active.offset,
+				activeAnchored: active.firstSequence !== void 0,
+				activePartial: active.pending.length > 0
+			};
+		} finally {
+			await this.closeSnapshot(segments);
+		}
+	}
+	pruneStates(segments) {
+		const retained = new Set(segments.map((entry) => entry.identity));
+		for (const identity of this.states.keys()) if (!retained.has(identity)) this.states.delete(identity);
+	}
+	async readSegment(handle, size, state, page, signal) {
+		if (size < state.offset) corrupt("Session journal was truncated while watching");
+		const buffer = Buffer.alloc(Math.min(65536, size - state.offset));
+		for (;;) {
+			signal?.throwIfAborted();
+			this.consumePending(state, page);
+			if (pageFull(page) || state.offset >= size) return;
+			const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, size - state.offset), state.offset);
+			if (bytesRead === 0) corrupt("Session journal changed while reading");
+			state.offset += bytesRead;
+			state.pending = Buffer.concat([state.pending, buffer.subarray(0, bytesRead)]);
+		}
+	}
+	consumePending(state, page) {
+		const pending = state.pending;
+		let start = 0;
+		for (let end = pending.indexOf(10); end >= 0; end = pending.indexOf(10, start)) {
+			this.consumeLine(pending.subarray(start, end).toString("utf8"), state, page, end - start + 1);
+			start = end + 1;
+			if (pageFull(page)) break;
+		}
+		state.pending = Buffer.from(pending.subarray(start));
+	}
+	consumeLine(line, state, page, bytes) {
+		const entry = decodeJournalLine(line, state.firstSequence !== void 0);
+		if (!entry) return;
+		if (entry.type === "marker") {
+			this.consumeMarker(entry.marker, state, page, bytes);
+			return;
+		}
+		if (state.firstSequence === void 0) return;
+		this.advance(state);
+		state.messageSequence += 1;
+		eventSink(page, state.sequence, bytes)?.push({
+			...this.eventPosition(state),
+			type: "message",
+			requestId: state.requestId,
+			message: entry.message
+		});
+	}
+	advance(state) {
+		state.sequence += 1;
+		if (!Number.isSafeInteger(state.sequence)) corrupt("Session journal sequence exceeds its supported range");
+	}
+	eventPosition(state) {
+		return {
+			sequence: state.sequence,
+			cursor: sessionWatchCursor(this.record.acpxRecordId, state.sequence)
+		};
+	}
+	consumeMarker(marker, state, page, bytes) {
+		if (marker.type === "segment") {
+			this.acceptAnchor(marker, state);
+			return;
+		}
+		if (state.firstSequence === void 0) corrupt("Session journal lifecycle record has no segment anchor");
+		this.advance(state);
+		if (marker.type === "turn_started") {
+			state.requestId = marker.request_id;
+			eventSink(page, state.sequence, bytes)?.push({
+				...this.eventPosition(state),
+				type: "turn_started",
+				requestId: state.requestId
+			});
+		} else {
+			if (state.requestId !== marker.request_id) corrupt("Session journal result does not match the active request");
+			eventSink(page, state.sequence, bytes)?.push({
+				...this.eventPosition(state),
+				type: "turn_result",
+				requestId: state.requestId,
+				result: marker.result
+			});
+			state.requestId = null;
+		}
+	}
+	acceptAnchor(anchor, state) {
+		if (state.firstSequence !== void 0 || anchor.record_id !== this.record.acpxRecordId) corrupt("Invalid session journal segment anchor");
+		state.firstSequence = anchor.sequence;
+		state.sequence = anchor.sequence;
+		state.messageSequence = anchor.message_sequence;
+		state.requestId = anchor.request_id;
+	}
+};
+function decodeJournalLine(line, anchored) {
+	let value;
+	try {
+		value = JSON.parse(line);
+	} catch {
+		if (anchored) corrupt("Invalid complete line in session journal");
+		return;
+	}
+	if (isAcpJsonRpcMessage(value)) return {
+		type: "message",
+		message: value
+	};
+	const marker = markerSchema.safeParse(value);
+	if (marker.success) return {
+		type: "marker",
+		marker: marker.data
+	};
+	if (anchored || hasJournalSchema(value)) corrupt("Invalid record in session journal");
+}
+function hasJournalSchema(value) {
+	return value !== null && typeof value === "object" && "schema" in value;
+}
+function watchSession(options) {
+	return { [Symbol.asyncIterator]() {
+		const stopped = new AbortController();
+		const signal = options.signal ? AbortSignal.any([options.signal, stopped.signal]) : stopped.signal;
+		const iterator = iterateSession({
+			...options,
+			signal
+		});
+		return {
+			next: () => iterator.next(),
+			return: async () => {
+				stopped.abort();
+				return await iterator.return();
+			}
+		};
+	} };
+}
+async function* iterateSession(options) {
+	const { signal } = options;
+	if (signal.aborted) return;
+	const record = await settleUnlessAborted(Promise.resolve(options.record), signal);
+	if (!record) return;
+	yield* iterateJournal(record, options);
+}
+async function* iterateJournal(record, options) {
+	const { signal } = options;
+	let after = options.cursor === void 0 ? -1 : parseCursor(record.acpxRecordId, options.cursor);
+	const reader = new SessionJournalReader(record);
+	let first = true;
+	for (;;) {
+		if (signal.aborted) return;
+		const snapshot = await settleUnlessAborted(reader.read(signal, {
+			after,
+			maxBytes: WATCH_PAGE_BYTES
+		}), signal);
+		if (!snapshot) return;
+		assertRetainedCursor(after, snapshot, first);
+		first = false;
+		for (const { sequence, ...event } of snapshot.events) {
+			if (signal.aborted) return;
+			after = sequence;
+			yield event;
+		}
+		if (!await continueAfterPage(record, snapshot, options)) return;
+	}
+}
+async function continueAfterPage(record, snapshot, options) {
+	if (!snapshot.hasMore && options.continueWatching) {
+		if (!await settleUnlessAborted(options.continueWatching(record, snapshot.requestId), options.signal)) return false;
+	}
+	await settleUnlessAborted(setTimeout$1(snapshot.hasMore ? 0 : 100, void 0, { signal: options.signal }), options.signal);
+	return !options.signal.aborted;
+}
+function assertRetainedCursor(after, snapshot, first) {
+	if (after < 0) return;
+	if (after > snapshot.sequence) throw new SessionWatchError(first ? "WATCH_CURSOR_FUTURE" : "WATCH_CURSOR_EXPIRED", "Cursor is beyond the available session journal");
+	if (snapshot.firstSequence !== void 0 && after < snapshot.firstSequence) throw new SessionWatchError("WATCH_CURSOR_EXPIRED", "Cursor is older than retained session history");
+}
+async function settleUnlessAborted(operation, signal) {
+	try {
+		return await operation;
+	} catch (error) {
+		if (signal?.aborted) return;
+		throw error;
+	}
+}
+//#endregion
+//#region src/acp/agent-session-id.ts
+const AGENT_SESSION_ID_META_KEYS = ["agentSessionId", "sessionId"];
+function normalizeAgentSessionId(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function asMetaRecord(meta) {
+	if (!meta || typeof meta !== "object" || Array.isArray(meta)) return;
+	return meta;
+}
+function extractAgentSessionId(meta) {
+	const record = asMetaRecord(meta);
+	if (!record) return;
+	for (const key of AGENT_SESSION_ID_META_KEYS) {
+		const normalized = normalizeAgentSessionId(record[key]);
+		if (normalized) return normalized;
+	}
+}
+//#endregion
+//#region src/session/persistence/serialize.ts
+function serializeSessionRecordForDisk(record) {
+	return {
+		schema: SESSION_RECORD_SCHEMA,
+		acpx_record_id: record.acpxRecordId,
+		acp_session_id: record.acpSessionId,
+		agent_session_id: normalizeAgentSessionId(record.agentSessionId),
+		agent_command: record.agentCommand,
+		agent_argv: record.agentArgv,
+		cwd: record.cwd,
+		name: record.name,
+		created_at: record.createdAt,
+		last_used_at: record.lastUsedAt,
+		last_seq: record.lastSeq,
+		last_request_id: record.lastRequestId,
+		event_log: record.eventLog,
+		closed: record.closed,
+		closed_at: record.closedAt,
+		pid: record.pid,
+		agent_started_at: record.agentStartedAt,
+		last_prompt_at: record.lastPromptAt,
+		last_agent_exit_code: record.lastAgentExitCode,
+		last_agent_exit_signal: record.lastAgentExitSignal,
+		last_agent_exit_at: record.lastAgentExitAt,
+		last_agent_disconnect_reason: record.lastAgentDisconnectReason,
+		protocol_version: record.protocolVersion,
+		agent_capabilities: record.agentCapabilities,
+		title: record.title,
+		messages: record.messages,
+		updated_at: record.updated_at,
+		cumulative_token_usage: record.cumulative_token_usage,
+		cumulative_cost: record.cumulative_cost,
+		request_token_usage: record.request_token_usage,
+		acpx: record.acpx,
+		imported_from: record.importedFrom ? {
+			record_id: record.importedFrom.recordId,
+			cwd_original: record.importedFrom.cwdOriginal,
+			exported_by: record.importedFrom.exportedBy,
+			exported_at: record.importedFrom.exportedAt
+		} : void 0
+	};
+}
+//#endregion
+//#region src/acp/builtin-command-migration.ts
+const LEGACY_AGENT_COMMANDS = {
+	pi: [
+		"npx pi-acp",
+		"npx pi-acp@^0.0.22",
+		"npx pi-acp@^0.0.26"
+	],
+	codex: [
+		"npx @zed-industries/codex-acp",
+		"npx @zed-industries/codex-acp@^0.9.5",
+		"npx @zed-industries/codex-acp@^0.10.0",
+		"npx @zed-industries/codex-acp@^0.11.1",
+		"npx @zed-industries/codex-acp@^0.12.0",
+		"npx -y @agentclientprotocol/codex-acp@^0.0.44",
+		"npx -y @agentclientprotocol/codex-acp@^1.1.4"
+	],
+	claude: [
+		"npx @zed-industries/claude-agent-acp",
+		"npx -y @zed-industries/claude-agent-acp",
+		"npx -y @zed-industries/claude-agent-acp@^0.21.0",
+		"npx -y @zed-industries/claude-agent-acp@^0.23.1",
+		"npx -y @zed-industries/claude-agent-acp@^0.24.2",
+		"npx -y @zed-industries/claude-agent-acp@^0.25.0",
+		"npx -y @zed-industries/claude-agent-acp@^0.31.0",
+		"npx -y @agentclientprotocol/claude-agent-acp@^0.36.1",
+		"npx -y @agentclientprotocol/claude-agent-acp@^0.37.0",
+		"npm exec @agentclientprotocol/claude-agent-acp@^0.36.1",
+		"npm exec @agentclientprotocol/claude-agent-acp@^0.37.0"
+	],
+	gemini: ["gemini", "gemini --experimental-acp"],
+	kiro: ["kiro-cli acp"],
+	mux: ["npx -y mux@^0.27.0 acp"],
+	opencode: ["npx opencode-ai"]
+};
+function currentArgv(name) {
+	const argv = AGENT_ARGV_REGISTRY[name];
+	return argv ? [...argv] : void 0;
+}
+function resolveAgentArgvForCommand(agentCommand) {
+	for (const [name, command] of Object.entries(AGENT_REGISTRY)) if (command === agentCommand) return currentArgv(name);
+	for (const [name, spec] of Object.entries(BUILT_IN_AGENT_PACKAGES)) if ((spec.legacyFallbackCommands ?? []).includes(agentCommand)) return currentArgv(name);
+	for (const [name, commands] of Object.entries(LEGACY_AGENT_COMMANDS)) if (commands.includes(agentCommand)) return currentArgv(name);
+}
+//#endregion
+//#region src/session/persistence/parse.ts
+function asRecord$3(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function hasOwn(source, key) {
+	return Object.prototype.hasOwnProperty.call(source, key);
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function parseOptionalAgentArgv(value) {
+	return isStringArray(value) && value.length > 0 && value[0]?.length > 0 ? value : void 0;
+}
+function parsePersistedAgentArgv(record) {
+	return parseOptionalAgentArgv(record.agent_argv) ?? (typeof record.agent_command === "string" ? resolveAgentArgvForCommand(record.agent_command) : void 0);
+}
+function hasModelConfigOption(options) {
+	if (!Array.isArray(options)) return false;
+	return options.some((entry) => {
+		const option = asRecord$3(entry);
+		return option?.category === "model" || option?.id === "model";
+	});
+}
+function parseConfigOptions(raw) {
+	if (!Array.isArray(raw) || !raw.every((entry) => asRecord$3(entry) !== void 0)) return;
+	return raw;
+}
+function parseAvailableCommand(raw) {
+	if (typeof raw === "string") {
+		const name = raw.trim();
+		return name ? { name } : void 0;
+	}
+	const record = asRecord$3(raw);
+	if (!record) return;
+	const name = parseNonEmptyString$1(record.name);
+	if (!name) return;
+	const description = parseNonEmptyString$1(record.description);
+	return {
+		name,
+		...description ? { description } : {},
+		...typeof record.has_input === "boolean" ? { has_input: record.has_input } : {}
+	};
+}
+function parseAvailableCommands(raw) {
+	if (!Array.isArray(raw)) return;
+	const commands = raw.map((entry) => parseAvailableCommand(entry)).filter((entry) => entry !== void 0);
+	return commands.length > 0 ? commands : void 0;
+}
+function parseNonEmptyString$1(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed ? trimmed : void 0;
+}
+function parseTokenUsage(raw) {
+	if (raw === void 0 || raw === null) return;
+	const record = asRecord$3(raw);
+	if (!record) return null;
+	const usage = {};
+	for (const field of [
+		"input_tokens",
+		"output_tokens",
+		"cache_creation_input_tokens",
+		"cache_read_input_tokens",
+		"thought_tokens",
+		"total_tokens"
+	]) {
+		const value = record[field];
+		if (value === void 0) continue;
+		if (!isNonNegativeFiniteNumber(value)) return null;
+		usage[field] = value;
+	}
+	return usage;
+}
+function isNonNegativeFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function parseUsageCost(raw) {
+	if (raw === void 0 || raw === null) return;
+	const record = asRecord$3(raw);
+	if (!record) return null;
+	return parseUsageCostRecord(record);
+}
+function parseUsageCostRecord(record) {
+	const amount = parseCostAmount(record.amount);
+	const currency = parseCostCurrency(record.currency);
+	if (amount === null || currency === null) return null;
+	const cost = {
+		...amount !== void 0 ? { amount } : {},
+		...currency !== void 0 ? { currency } : {}
+	};
+	return Object.keys(cost).length > 0 ? cost : void 0;
+}
+function parseCostAmount(value) {
+	if (value === void 0) return;
+	return isNonNegativeFiniteNumber(value) ? value : null;
+}
+function parseCostCurrency(value) {
+	if (value === void 0) return;
+	if (typeof value !== "string") return null;
+	const currency = value.trim();
+	return currency.length > 0 ? currency : void 0;
+}
+function parseRequestTokenUsage(raw) {
+	if (raw === void 0 || raw === null) return;
+	const record = asRecord$3(raw);
+	if (!record) return null;
+	const usage = {};
+	for (const [key, value] of Object.entries(record)) {
+		const parsed = parseTokenUsage(value);
+		if (parsed == null) return null;
+		usage[key] = parsed;
+	}
+	return usage;
+}
+function isSessionMessageImage(raw) {
+	const record = asRecord$3(raw);
+	if (!record || typeof record.source !== "string") return false;
+	if (record.size === void 0 || record.size === null) return true;
+	const size = asRecord$3(record.size);
+	return !!size && isFiniteNumber(size.width) && isFiniteNumber(size.height);
+}
+function isSessionMessageAudio(raw) {
+	const record = asRecord$3(raw);
+	return !!record && typeof record.source === "string" && typeof record.mime_type === "string";
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isUserContent(raw) {
+	const record = asRecord$3(raw);
+	if (!record) return false;
+	if (typeof record.Text === "string") return true;
+	if (record.Mention !== void 0) {
+		const mention = asRecord$3(record.Mention);
+		return !!mention && typeof mention.uri === "string" && typeof mention.content === "string";
+	}
+	if (record.Image !== void 0) return isSessionMessageImage(record.Image);
+	if (record.Audio !== void 0) return isSessionMessageAudio(record.Audio);
+	return false;
+}
+function isToolUse(raw) {
+	const record = asRecord$3(raw);
+	return !!record && hasStringFields$1(record, [
+		"id",
+		"name",
+		"raw_input"
+	]) && hasOwn(record, "input") && typeof record.is_input_complete === "boolean" && isOptionalString(record.thought_signature);
+}
+function hasStringFields$1(record, keys) {
+	return keys.every((key) => typeof record[key] === "string");
+}
+function isOptionalString(value) {
+	return value === void 0 || value === null || typeof value === "string";
+}
+function isToolResultContent(raw) {
+	const record = asRecord$3(raw);
+	if (!record) return false;
+	if (typeof record.Text === "string") return true;
+	if (record.Image !== void 0) return isSessionMessageImage(record.Image);
+	return false;
+}
+function isToolResult(raw) {
+	const record = asRecord$3(raw);
+	return !!record && typeof record.tool_use_id === "string" && typeof record.tool_name === "string" && typeof record.is_error === "boolean" && isToolResultContent(record.content);
+}
+function isAgentContent(raw) {
+	const record = asRecord$3(raw);
+	if (!record) return false;
+	if (typeof record.Text === "string") return true;
+	if (record.Thinking !== void 0) return isThinkingContent(record.Thinking);
+	if (typeof record.RedactedThinking === "string") return true;
+	if (record.ToolUse !== void 0) return isToolUse(record.ToolUse);
+	return false;
+}
+function isThinkingContent(raw) {
+	const thinking = asRecord$3(raw);
+	return !!thinking && typeof thinking.text === "string" && isOptionalString(thinking.signature);
+}
+function isUserMessage(raw) {
+	const record = asRecord$3(raw);
+	if (!record || record.User === void 0) return false;
+	const user = asRecord$3(record.User);
+	return !!user && typeof user.id === "string" && Array.isArray(user.content) && user.content.every((entry) => isUserContent(entry));
+}
+function isAgentMessage(raw) {
+	const record = asRecord$3(raw);
+	if (!record || record.Agent === void 0) return false;
+	const agent = asRecord$3(record.Agent);
+	if (!agent || !Array.isArray(agent.content) || !agent.content.every(isAgentContent)) return false;
+	const toolResults = asRecord$3(agent.tool_results);
+	if (!toolResults) return false;
+	return Object.values(toolResults).every(isToolResult);
+}
+function isConversationMessage(raw) {
+	return raw === "Resume" || isUserMessage(raw) || isAgentMessage(raw);
+}
+function parseConversationRecord(record) {
+	if (!hasValidConversationCore(record)) return;
+	const title = parseConversationTitle(record.title);
+	if (title === INVALID_VALUE) return;
+	const cumulativeTokenUsage = parseTokenUsage(record.cumulative_token_usage);
+	const cumulativeCost = parseUsageCost(record.cumulative_cost);
+	const requestTokenUsage = parseRequestTokenUsage(record.request_token_usage);
+	if (cumulativeTokenUsage === null || cumulativeCost === null || requestTokenUsage === null) return;
+	return {
+		title,
+		messages: record.messages,
+		updated_at: record.updated_at,
+		cumulative_token_usage: cumulativeTokenUsage ?? {},
+		cumulative_cost: cumulativeCost,
+		request_token_usage: requestTokenUsage ?? {}
+	};
+}
+const INVALID_VALUE = Symbol("invalid");
+function parseConversationTitle(value) {
+	if (value === void 0 || value === null || typeof value === "string") return value;
+	return INVALID_VALUE;
+}
+function hasValidConversationCore(record) {
+	return Array.isArray(record.messages) && record.messages.every(isConversationMessage) && typeof record.updated_at === "string";
+}
+function parseAcpxState(raw) {
+	const record = asRecord$3(raw);
+	if (!record) return;
+	const state = {};
+	if (record.reset_on_next_ensure === true) state.reset_on_next_ensure = true;
+	assignStringState(state, "current_mode_id", record.current_mode_id);
+	assignStringState(state, "desired_mode_id", record.desired_mode_id);
+	const desiredConfigOptions = parseStringMap(record.desired_config_options);
+	if (desiredConfigOptions) state.desired_config_options = desiredConfigOptions;
+	const modelNames = parseStringMap(record.available_model_names, true);
+	if (modelNames) state.available_model_names = modelNames;
+	assignParsedModelState(state, record);
+	const availableCommands = parseAvailableCommands(record.available_commands);
+	if (availableCommands) state.available_commands = availableCommands;
+	assignParsedSessionOptions(state, record.session_options);
+	return state;
+}
+function assignParsedModelState(state, record) {
+	assignStringState(state, "current_model_id", record.current_model_id);
+	if (isStringArray(record.available_models)) state.available_models = [...record.available_models];
+	if (record.model_control === "config_option" || record.model_control === "legacy_set_model") state.model_control = record.model_control;
+	const configOptions = parseConfigOptions(record.config_options);
+	if (configOptions) state.config_options = configOptions;
+	if (state.model_control === void 0 && state.available_models !== void 0) state.model_control = hasModelConfigOption(state.config_options) ? "config_option" : "legacy_set_model";
+}
+function assignStringState(state, key, value) {
+	if (typeof value === "string") state[key] = value;
+}
+function parseStringMap(raw, preserveEmpty = false) {
+	const record = asRecord$3(raw);
+	if (!record) return;
+	const parsed = Object.fromEntries(Object.entries(record).filter((entry) => typeof entry[1] === "string"));
+	return Object.keys(parsed).length > 0 || preserveEmpty ? parsed : void 0;
+}
+function assignParsedSessionOptions(state, raw) {
+	const sessionOptions = asRecord$3(raw);
+	if (!sessionOptions) return;
+	const parsedSessionOptions = {};
+	if (typeof sessionOptions.model === "string") parsedSessionOptions.model = sessionOptions.model;
+	if (isStringArray(sessionOptions.allowed_tools)) parsedSessionOptions.allowed_tools = [...sessionOptions.allowed_tools];
+	if (isPositiveInteger$1(sessionOptions.max_turns)) parsedSessionOptions.max_turns = sessionOptions.max_turns;
+	assignSessionOptionSystemPrompt(parsedSessionOptions, sessionOptions.system_prompt);
+	const env = parseStringMap(sessionOptions.env);
+	if (env) parsedSessionOptions.env = env;
+	if (Object.keys(parsedSessionOptions).length > 0) state.session_options = parsedSessionOptions;
+}
+function assignSessionOptionSystemPrompt(options, value) {
+	if (typeof value === "string" && value.length > 0) {
+		options.system_prompt = value;
+		return;
+	}
+	const appendRecord = asRecord$3(value);
+	if (appendRecord && typeof appendRecord.append === "string" && appendRecord.append.length > 0) options.system_prompt = { append: appendRecord.append };
+}
+function parseEventLog(raw, sessionId) {
+	const record = asRecord$3(raw);
+	if (!record || !hasValidEventLogCore(record)) return defaultSessionEventLog(sessionId);
+	return {
+		active_path: record.active_path,
+		segment_count: record.segment_count,
+		max_segment_bytes: record.max_segment_bytes,
+		max_segments: record.max_segments,
+		last_write_at: typeof record.last_write_at === "string" ? record.last_write_at : void 0,
+		last_write_error: record.last_write_error == null || typeof record.last_write_error === "string" ? record.last_write_error : null
+	};
+}
+function hasValidEventLogCore(record) {
+	return typeof record.active_path === "string" && isPositiveInteger$1(record.segment_count) && isPositiveInteger$1(record.max_segment_bytes) && isPositiveInteger$1(record.max_segments);
+}
+function isPositiveInteger$1(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function parseImportedFrom(raw) {
+	if (raw == null) return;
+	const record = asRecord$3(raw);
+	if (!record || typeof record.record_id !== "string" || typeof record.cwd_original !== "string" || typeof record.exported_by !== "string" || typeof record.exported_at !== "string") return null;
+	return {
+		recordId: record.record_id,
+		cwdOriginal: record.cwd_original,
+		exportedBy: record.exported_by,
+		exportedAt: record.exported_at
+	};
+}
+function parseSessionRecordMetadata(record) {
+	const lastRequestId = normalizeOptionalString(record.last_request_id);
+	if (lastRequestId === null) return null;
+	const importedFrom = parseImportedFrom(record.imported_from);
+	if (importedFrom === null) return null;
+	return {
+		lastRequestId,
+		importedFrom
+	};
+}
+function normalizeOptionalName(value) {
+	if (value == null) return;
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function normalizeOptionalPid(value) {
+	if (value == null) return;
+	return isPositiveInteger$1(value) ? value : null;
+}
+function normalizeOptionalBoolean(value, fallback = false) {
+	if (value == null) return fallback;
+	return typeof value === "boolean" ? value : null;
+}
+function normalizeOptionalString(value) {
+	if (value == null) return;
+	return typeof value === "string" ? value : null;
+}
+function normalizeOptionalExitCode(value) {
+	if (value === void 0) return;
+	if (value === null) return null;
+	if (Number.isInteger(value)) return value;
+	return Symbol("invalid");
+}
+function normalizeOptionalSignal(value) {
+	if (value === void 0) return;
+	if (value === null) return null;
+	if (typeof value === "string") return value;
+	return Symbol("invalid");
+}
+function parseSessionRecord(raw) {
+	const record = asRecord$3(raw);
+	if (!record) return null;
+	if (record.schema !== "acpx.session.v1") return null;
+	const optionals = validSessionOptionals({
+		name: normalizeOptionalName(record.name),
+		pid: normalizeOptionalPid(record.pid),
+		closed: normalizeOptionalBoolean(record.closed, false),
+		closedAt: normalizeOptionalString(record.closed_at),
+		agentStartedAt: normalizeOptionalString(record.agent_started_at),
+		lastPromptAt: normalizeOptionalString(record.last_prompt_at),
+		lastAgentExitCode: normalizeOptionalExitCode(record.last_agent_exit_code),
+		lastAgentExitSignal: normalizeOptionalSignal(record.last_agent_exit_signal),
+		lastAgentExitAt: normalizeOptionalString(record.last_agent_exit_at),
+		lastAgentDisconnectReason: normalizeOptionalString(record.last_agent_disconnect_reason)
+	});
+	if (!hasValidSessionRecordCore(record) || !optionals) return null;
+	const conversation = parseConversationRecord(record);
+	if (!conversation) return null;
+	const eventLog = parseEventLog(record.event_log, record.acpx_record_id);
+	const metadata = parseSessionRecordMetadata(record);
+	if (!metadata) return null;
+	return {
+		schema: SESSION_RECORD_SCHEMA,
+		acpxRecordId: record.acpx_record_id,
+		acpSessionId: record.acp_session_id,
+		agentSessionId: normalizeAgentSessionId(record.agent_session_id),
+		agentCommand: record.agent_command,
+		agentArgv: parsePersistedAgentArgv(record),
+		cwd: record.cwd,
+		name: optionals.name,
+		createdAt: record.created_at,
+		lastUsedAt: record.last_used_at,
+		lastSeq: record.last_seq,
+		lastRequestId: metadata.lastRequestId,
+		eventLog,
+		closed: optionals.closed,
+		closedAt: optionals.closedAt,
+		pid: optionals.pid,
+		agentStartedAt: optionals.agentStartedAt,
+		lastPromptAt: optionals.lastPromptAt,
+		lastAgentExitCode: optionals.lastAgentExitCode,
+		lastAgentExitSignal: optionals.lastAgentExitSignal,
+		lastAgentExitAt: optionals.lastAgentExitAt,
+		lastAgentDisconnectReason: optionals.lastAgentDisconnectReason,
+		protocolVersion: typeof record.protocol_version === "number" ? record.protocol_version : void 0,
+		agentCapabilities: asRecord$3(record.agent_capabilities),
+		title: conversation.title,
+		messages: conversation.messages,
+		updated_at: conversation.updated_at,
+		cumulative_token_usage: conversation.cumulative_token_usage,
+		cumulative_cost: conversation.cumulative_cost,
+		request_token_usage: conversation.request_token_usage,
+		acpx: parseAcpxState(record.acpx),
+		importedFrom: metadata.importedFrom
+	};
+}
+function hasValidSessionRecordCore(record) {
+	return hasStringFields$1(record, [
+		"acpx_record_id",
+		"acp_session_id",
+		"agent_command",
+		"cwd",
+		"created_at",
+		"last_used_at"
+	]) && typeof record.last_seq === "number" && Number.isInteger(record.last_seq) && record.last_seq >= 0;
+}
+function validSessionOptionals(options) {
+	if (hasNullOptionalSessionFields(options) || hasInvalidExitStatus(options)) return null;
+	return options;
+}
+function hasNullOptionalSessionFields(options) {
+	return [
+		options.name,
+		options.pid,
+		options.closed,
+		options.closedAt,
+		options.agentStartedAt,
+		options.lastPromptAt,
+		options.lastAgentExitAt,
+		options.lastAgentDisconnectReason
+	].some((value) => value === null);
+}
+function hasInvalidExitStatus(options) {
+	return typeof options.lastAgentExitCode === "symbol" || typeof options.lastAgentExitSignal === "symbol";
+}
+//#endregion
+//#region src/persisted-key-policy.ts
+const SNAKE_CASE_KEY = /^[a-z][a-z0-9_]*$/;
+const ZED_TAG_KEYS = /* @__PURE__ */ new Set([
+	"User",
+	"Agent",
+	"Resume",
+	"Text",
+	"Mention",
+	"Image",
+	"Audio",
+	"Thinking",
+	"RedactedThinking",
+	"ToolUse"
+]);
+const MAP_OBJECT_PATHS = /* @__PURE__ */ new Set([
+	"request_token_usage",
+	"messages.Agent.tool_results",
+	"acpx.session_options.env",
+	"acpx.available_model_names"
+]);
+const OPAQUE_VALUE_PATHS = /* @__PURE__ */ new Set([
+	"agent_capabilities",
+	"messages.Agent.content.ToolUse.input",
+	"acpx.desired_config_options",
+	"acpx.config_options"
+]);
+function isRecord(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function joinPath(path) {
+	return path.join(".");
+}
+function shouldSkipKeyRule(path) {
+	return MAP_OBJECT_PATHS.has(joinPath(path));
+}
+function shouldSkipDescend(path) {
+	return OPAQUE_VALUE_PATHS.has(joinPath(path)) || isToolResultOutputPath(path);
+}
+function isToolResultOutputTail(path, toolResultsIndex) {
+	return toolResultsIndex !== -1 && toolResultsIndex + 2 === path.length - 1;
+}
+function isToolResultOutputPath(path) {
+	if (path.length < 5 || path[path.length - 1] !== "output") return false;
+	const toolResultsIndex = path.lastIndexOf("tool_results");
+	if (!isToolResultOutputTail(path, toolResultsIndex)) return false;
+	return path.slice(0, toolResultsIndex + 1).join(".") === "messages.Agent.tool_results";
+}
+function collectViolations(value, path, violations) {
+	if (Array.isArray(value)) {
+		for (const entry of value) collectViolations(entry, path, violations);
+		return;
+	}
+	if (!isRecord(value)) return;
+	const skipKeyRule = shouldSkipKeyRule(path);
+	for (const [key, child] of Object.entries(value)) collectKeyViolation(child, key, path, skipKeyRule, violations);
+}
+function collectKeyViolation(child, key, path, skipKeyRule, violations) {
+	if (!skipKeyRule && !SNAKE_CASE_KEY.test(key) && !ZED_TAG_KEYS.has(key)) violations.push(`${joinPath(path)}.${key}`.replace(/^\./, ""));
+	const childPath = [...path, key];
+	if (!shouldSkipDescend(childPath)) collectViolations(child, childPath, violations);
+}
+function findPersistedKeyPolicyViolations(value) {
+	const violations = [];
+	collectViolations(value, [], violations);
+	return violations;
+}
+function assertPersistedKeyPolicy(value) {
+	const violations = findPersistedKeyPolicyViolations(value);
+	if (violations.length === 0) return;
+	throw new Error(`Persisted key policy violation (expected snake_case keys): ${violations.join(", ")}`);
+}
+//#endregion
+//#region src/session/persistence/index.ts
+const SESSION_INDEX_SCHEMA = "acpx.session-index.v1";
+function asRecord$2(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function parseIndexEntry(raw) {
+	const record = asRecord$2(raw);
+	if (!record) return;
+	if (!hasRequiredIndexEntryFields(record)) return;
+	if (record.name !== void 0 && typeof record.name !== "string") return;
+	return {
+		file: record.file,
+		acpxRecordId: record.acpxRecordId,
+		acpSessionId: record.acpSessionId,
+		agentCommand: record.agentCommand,
+		cwd: record.cwd,
+		name: record.name,
+		closed: record.closed,
+		lastUsedAt: record.lastUsedAt
+	};
+}
+function hasRequiredIndexEntryFields(record) {
+	return [
+		"file",
+		"acpxRecordId",
+		"acpSessionId",
+		"agentCommand",
+		"cwd",
+		"lastUsedAt"
+	].every((key) => typeof record[key] === "string") && typeof record.closed === "boolean";
+}
+function sessionIndexPath(sessionDir) {
+	return path.join(sessionDir, "index.json");
+}
+function toSessionIndexEntry(record, fileName) {
+	return {
+		file: fileName,
+		acpxRecordId: record.acpxRecordId,
+		acpSessionId: record.acpSessionId,
+		agentCommand: record.agentCommand,
+		cwd: record.cwd,
+		name: record.name,
+		closed: record.closed === true,
+		lastUsedAt: record.lastUsedAt
+	};
+}
+async function readSessionIndex(sessionDir) {
+	const filePath = sessionIndexPath(sessionDir);
+	try {
+		const payload = await fs$1.readFile(filePath, "utf8");
+		const record = asRecord$2(JSON.parse(payload));
+		if (!record || record.schema !== SESSION_INDEX_SCHEMA || !Array.isArray(record.files)) return;
+		const files = record.files.filter((entry) => typeof entry === "string");
+		if (files.length !== record.files.length || !Array.isArray(record.entries)) return;
+		const entries = record.entries.map((entry) => parseIndexEntry(entry)).filter((entry) => Boolean(entry));
+		if (entries.length !== record.entries.length) return;
+		return {
+			schema: SESSION_INDEX_SCHEMA,
+			files,
+			entries
+		};
+	} catch {
+		return;
+	}
+}
+async function writeSessionIndex(sessionDir, index) {
+	await writePrivateJsonFile(sessionIndexPath(sessionDir), {
+		schema: SESSION_INDEX_SCHEMA,
+		files: index.files.toSorted(),
+		entries: index.entries.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))
+	});
+}
+async function rebuildSessionIndex(sessionDir) {
+	const index = await scanSessionIndex(sessionDir);
+	await writeSessionIndex(sessionDir, index);
+	return index;
+}
+async function scanSessionIndex(sessionDir) {
+	const files = await listSessionFiles(sessionDir).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	});
+	const indexEntries = [];
+	for (const file of files) try {
+		const payload = await fs$1.readFile(path.join(sessionDir, file), "utf8");
+		const parsed = parseSessionRecord(JSON.parse(payload));
+		if (!parsed) continue;
+		indexEntries.push(toSessionIndexEntry(parsed, file));
+	} catch {}
+	return {
+		schema: SESSION_INDEX_SCHEMA,
+		files,
+		entries: indexEntries.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))
+	};
+}
+async function loadOrRebuildSessionIndex(sessionDir) {
+	const files = await listSessionFiles(sessionDir);
+	const existing = await readSessionIndex(sessionDir);
+	if (existing && existing.files.length === files.length && existing.files.every((file, index) => file === files[index])) return existing;
+	return await rebuildSessionIndex(sessionDir);
+}
+async function listSessionFiles(sessionDir) {
+	return (await fs$1.readdir(sessionDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name !== "index.json").map((entry) => entry.name).toSorted();
+}
+//#endregion
+//#region src/session/persistence/repository.ts
+const DEFAULT_HISTORY_LIMIT = 20;
+function sessionFilePath(acpxRecordId) {
+	const safeId = safeSessionId(acpxRecordId);
+	return path.join(sessionBaseDir(), `${safeId}.json`);
+}
+async function ensureSessionDir() {
+	await fs$1.mkdir(sessionBaseDir(), {
+		recursive: true,
+		mode: 448
+	});
+}
+async function loadRecordFromIndexEntry(entry) {
+	try {
+		const payload = await fs$1.readFile(path.join(sessionBaseDir(), entry.file), "utf8");
+		return parseSessionRecord(JSON.parse(payload)) ?? void 0;
+	} catch {
+		return;
+	}
+}
+async function loadSessionIndexEntries(readOnly = false) {
+	if (!readOnly) await ensureSessionDir();
+	return (await measurePerf("session.index_load", async () => {
+		return await (readOnly ? scanSessionIndex : loadOrRebuildSessionIndex)(sessionBaseDir());
+	})).entries;
+}
+function matchesSessionEntry(session, normalizedCwd, normalizedName, includeClosed = false) {
+	if (session.cwd !== normalizedCwd) return false;
+	if (!includeClosed && session.closed) return false;
+	if (normalizedName == null) return session.name == null;
+	return session.name === normalizedName;
+}
+async function writeSessionRecord(record) {
+	await measurePerf("session.write_record", async () => {
+		const persisted = serializeSessionRecordForDisk(record);
+		assertPersistedKeyPolicy(persisted);
+		const file = sessionFilePath(record.acpxRecordId);
+		await writePrivateJsonFile(file, persisted);
+		const sessionDir = sessionBaseDir();
+		const index = await loadOrRebuildSessionIndex(sessionDir);
+		const fileName = path.basename(file);
+		const entries = index.entries.filter((entry) => entry.file !== fileName);
+		entries.push(toSessionIndexEntry(record, fileName));
+		await writeSessionIndex(sessionDir, {
+			files: [.../* @__PURE__ */ new Set([...index.files.filter((entry) => entry !== fileName), fileName])],
+			entries
+		});
+	});
+}
+async function resolveSessionRecord(sessionId) {
+	await ensureSessionDir();
+	try {
+		const directRecord = await measurePerf("session.resolve_direct", async () => await readSessionRecord(sessionId));
+		if (directRecord) return directRecord;
+	} catch {}
+	const entries = await loadSessionIndexEntries();
+	const exactEntries = entries.filter((entry) => entry.acpxRecordId === sessionId || entry.acpSessionId === sessionId);
+	const exactRecords = (await Promise.all(exactEntries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry));
+	if (exactRecords.length === 1) return exactRecords[0];
+	if (exactRecords.length > 1) throw new SessionResolutionError(`Multiple sessions match id: ${sessionId}`);
+	const suffixEntries = entries.filter((entry) => entry.acpxRecordId.endsWith(sessionId) || entry.acpSessionId.endsWith(sessionId));
+	const suffixRecords = (await Promise.all(suffixEntries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry));
+	if (suffixRecords.length === 1) return suffixRecords[0];
+	if (suffixRecords.length > 1) throw new SessionResolutionError(`Session id is ambiguous: ${sessionId}`);
+	incrementPerfCounter("session.resolve_miss");
+	throw new SessionNotFoundError(sessionId);
+}
+/** Reads a canonical record without creating directories or rebuilding the lookup index. */
+async function readSessionRecord(sessionId) {
+	let payload;
+	try {
+		payload = await fs$1.readFile(sessionFilePath(sessionId), "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	try {
+		return parseSessionRecord(JSON.parse(payload)) ?? void 0;
+	} catch {
+		return;
+	}
+}
+function hasGitDirectory(dir) {
+	const gitPath = path.join(dir, ".git");
+	try {
+		return statSync(gitPath).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function isWithinBoundary(boundary, target) {
+	const relative = path.relative(boundary, target);
+	return relative.length === 0 || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function absolutePath(value) {
+	return path.resolve(value);
+}
+function findGitRepositoryRoot(startDir) {
+	let current = absolutePath(startDir);
+	const root = path.parse(current).root;
+	for (;;) {
+		if (hasGitDirectory(current)) return current;
+		if (current === root) return;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function normalizeName(value) {
+	if (value == null) return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function isoNow() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function listSessions() {
+	await ensureSessionDir();
+	const entries = await loadSessionIndexEntries();
+	const records = [];
+	for (const entry of entries) {
+		const parsed = await loadRecordFromIndexEntry(entry);
+		if (parsed) records.push(parsed);
+	}
+	records.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+	return records;
+}
+async function listSessionsForAgent(agentCommand) {
+	const entries = (await loadSessionIndexEntries()).filter((session) => session.agentCommand === agentCommand);
+	return (await Promise.all(entries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry)).toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+}
+async function findSession(options) {
+	const normalizedCwd = absolutePath(options.cwd);
+	const normalizedName = normalizeName(options.name);
+	const match = (await loadSessionIndexEntries(options.readOnly)).find((session) => session.agentCommand === options.agentCommand && matchesSessionEntry(session, normalizedCwd, normalizedName, options.includeClosed));
+	if (!match) return;
+	return await loadRecordFromIndexEntry(match);
+}
+async function findSessionByDirectoryWalk(options) {
+	const normalizedName = normalizeName(options.name);
+	const normalizedStart = absolutePath(options.cwd);
+	const normalizedBoundary = absolutePath(options.boundary ?? normalizedStart);
+	const walkBoundary = isWithinBoundary(normalizedBoundary, normalizedStart) ? normalizedBoundary : normalizedStart;
+	const sessions = (await loadSessionIndexEntries()).filter((session) => session.agentCommand === options.agentCommand);
+	let current = normalizedStart;
+	const walkRoot = path.parse(current).root;
+	for (;;) {
+		const match = sessions.find((session) => matchesSessionEntry(session, current, normalizedName));
+		if (match) return await loadRecordFromIndexEntry(match);
+		const parent = nextWalkParent(current, walkBoundary, walkRoot);
+		if (!parent) return;
+		current = parent;
+	}
+}
+function nextWalkParent(current, walkBoundary, walkRoot) {
+	if (current === walkBoundary || current === walkRoot) return;
+	const parent = path.dirname(current);
+	if (parent === current || !isWithinBoundary(walkBoundary, parent)) return;
+	return parent;
+}
+function closedAtOrLastUsedAt(record) {
+	return record.closedAt ?? record.lastUsedAt;
+}
+function isSessionStreamFile(fileName, safeId) {
+	return fileName === `${safeId}.stream.ndjson` || fileName === `${safeId}.stream.lock` || fileName.startsWith(`${safeId}.stream.`);
+}
+async function pruneSessions(options = {}) {
+	await ensureSessionDir();
+	const records = await loadPrunableRecords(filterPruneCandidates(await loadSessionIndexEntries(), options.agentCommand), options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0));
+	if (options.dryRun) return {
+		pruned: records,
+		bytesFreed: 0,
+		dryRun: true
+	};
+	const sessionDir = sessionBaseDir();
+	let bytesFreed = 0;
+	let dirEntries = [];
+	if (options.includeHistory) try {
+		dirEntries = await fs$1.readdir(sessionDir);
+	} catch {}
+	for (const record of records) bytesFreed += await pruneSessionFiles(record, sessionDir, dirEntries, options.includeHistory === true);
+	await rebuildSessionIndex(sessionDir).catch(() => {});
+	return {
+		pruned: records,
+		bytesFreed,
+		dryRun: false
+	};
+}
+function filterPruneCandidates(entries, agentCommand) {
+	return entries.filter((entry) => entry.closed && (!agentCommand || entry.agentCommand === agentCommand));
+}
+async function loadPrunableRecords(entries, cutoff) {
+	const records = [];
+	const cutoffIso = cutoff?.toISOString();
+	for (const entry of entries) {
+		const record = await loadRecordFromIndexEntry(entry);
+		if (record && isBeforeCutoff(record, cutoffIso)) records.push(record);
+	}
+	return records;
+}
+function isBeforeCutoff(record, cutoffIso) {
+	return !cutoffIso || closedAtOrLastUsedAt(record) < cutoffIso;
+}
+async function pruneSessionFiles(record, sessionDir, dirEntries, includeHistory) {
+	const safeId = safeSessionId(record.acpxRecordId);
+	let bytesFreed = await unlinkCountingBytes(path.join(sessionDir, `${safeId}.json`));
+	if (includeHistory) for (const name of dirEntries.filter((entry) => isSessionStreamFile(entry, safeId))) bytesFreed += await unlinkCountingBytes(path.join(sessionDir, name));
+	return bytesFreed;
+}
+async function unlinkCountingBytes(filePath) {
+	let bytes = 0;
+	try {
+		bytes = (await fs$1.stat(filePath)).size;
+	} catch {}
+	await fs$1.unlink(filePath).catch(() => void 0);
+	return bytes;
+}
+//#endregion
+//#region src/prompt-content.ts
+var PromptInputValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PromptInputValidationError";
+	}
+};
+function asRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isBase64Data(value) {
+	if (value.length === 0 || value.length % 4 !== 0) return false;
+	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+}
+function isImageMimeType(value) {
+	return /^image\/[A-Za-z0-9.+-]+$/i.test(value);
+}
+function isAudioMimeType(value) {
+	return /^audio\/[A-Za-z0-9.+-]+$/i.test(value);
+}
+function isTextBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "text" && typeof record.text === "string";
+}
+function isImageBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "image" && isNonEmptyString(record.mimeType) && isImageMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
+}
+function isAudioBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "audio" && isNonEmptyString(record.mimeType) && isAudioMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
+}
+function isResourceLinkBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "resource_link" && isNonEmptyString(record.uri) && (record.title === void 0 || typeof record.title === "string") && (record.name === void 0 || typeof record.name === "string");
+}
+function isResourcePayload(value) {
+	const record = asRecord$1(value);
+	if (!record || !isNonEmptyString(record.uri)) return false;
+	return record.text === void 0 || typeof record.text === "string";
+}
+function isResourceBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "resource" && isResourcePayload(record.resource);
+}
+const CONTENT_BLOCK_VALIDATORS = [
+	isTextBlock,
+	isImageBlock,
+	isAudioBlock,
+	isResourceLinkBlock,
+	isResourceBlock
+];
+function isContentBlock(value) {
+	return CONTENT_BLOCK_VALIDATORS.some((validator) => validator(value));
+}
+const CONTENT_BLOCK_ERROR_VALIDATORS = {
+	text: validateTextContentBlock,
+	image: validateImageContentBlock,
+	audio: validateAudioContentBlock,
+	resource_link: validateResourceLinkContentBlock,
+	resource: validateResourceContentBlock
+};
+function contentBlockErrorValidator(type) {
+	return Object.hasOwn(CONTENT_BLOCK_ERROR_VALIDATORS, type) ? CONTENT_BLOCK_ERROR_VALIDATORS[type] : void 0;
+}
+function validateTextContentBlock(record, index) {
+	return typeof record.text === "string" ? void 0 : `prompt[${index}] text block must include a string text field`;
+}
+function validateImageContentBlock(record, index) {
+	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] image block must include a non-empty mimeType`;
+	if (!isImageMimeType(record.mimeType)) return `prompt[${index}] image block mimeType must start with image/`;
+	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] image block must include non-empty base64 data`;
+	return isBase64Data(record.data) ? void 0 : `prompt[${index}] image block data must be valid base64`;
+}
+function validateAudioContentBlock(record, index) {
+	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] audio block must include a non-empty mimeType`;
+	if (!isAudioMimeType(record.mimeType)) return `prompt[${index}] audio block mimeType must start with audio/`;
+	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] audio block must include non-empty base64 data`;
+	return isBase64Data(record.data) ? void 0 : `prompt[${index}] audio block data must be valid base64`;
+}
+function validateResourceLinkContentBlock(record, index) {
+	if (!isNonEmptyString(record.uri)) return `prompt[${index}] resource_link block must include a non-empty uri`;
+	if (record.title !== void 0 && typeof record.title !== "string") return `prompt[${index}] resource_link block title must be a string when present`;
+	if (record.name !== void 0 && typeof record.name !== "string") return `prompt[${index}] resource_link block name must be a string when present`;
+}
+function validateResourceContentBlock(record, index) {
+	if (!asRecord$1(record.resource)) return `prompt[${index}] resource block must include a resource object`;
+	return isResourcePayload(record.resource) ? void 0 : `prompt[${index}] resource block resource must include a non-empty uri and optional text`;
+}
+function getContentBlockValidationError(value, index) {
+	const record = asRecord$1(value);
+	if (!record || typeof record.type !== "string") return `prompt[${index}] must be an ACP content block object`;
+	const validator = contentBlockErrorValidator(record.type);
+	return validator ? validator(record, index) : `prompt[${index}] has unsupported content block type ${JSON.stringify(record.type)}`;
+}
+function isPromptInput(value) {
+	return Array.isArray(value) && value.every((entry) => isContentBlock(entry));
+}
+function promptCapabilityRequirement(block) {
+	switch (block.type) {
+		case "image": return {
+			blockType: "image",
+			capability: "image"
+		};
+		case "audio": return {
+			blockType: "audio",
+			capability: "audio"
+		};
+		case "resource": return {
+			blockType: "resource",
+			capability: "embeddedContext"
+		};
+		default: return;
+	}
+}
+function getUnsupportedPromptContentMessage(prompt, agentCapabilities) {
+	for (const [index, block] of prompt.entries()) {
+		const requirement = promptCapabilityRequirement(block);
+		if (!requirement) continue;
+		if (agentCapabilities?.promptCapabilities?.[requirement.capability] === true) continue;
+		return `prompt[${index}] ${requirement.blockType} content requires agentCapabilities.promptCapabilities.${requirement.capability}`;
+	}
+}
+function textPrompt(text) {
+	return [{
+		type: "text",
+		text
+	}];
+}
+function parseStructuredPrompt(source) {
+	if (!source.startsWith("[")) return;
+	try {
+		const parsed = JSON.parse(source);
+		if (isPromptInput(parsed)) return parsed;
+		if (Array.isArray(parsed)) throw new PromptInputValidationError(parsed.map((entry, index) => getContentBlockValidationError(entry, index)).find((message) => message !== void 0) ?? "Structured prompt JSON must be an array of valid ACP content blocks");
+		return;
+	} catch (error) {
+		if (error instanceof PromptInputValidationError) throw error;
+		return;
+	}
+}
+function parsePromptSource(source) {
+	const trimmed = source.trim();
+	const structured = parseStructuredPrompt(trimmed);
+	if (structured) return structured;
+	if (!trimmed) return [];
+	return textPrompt(trimmed);
+}
+function mergePromptSourceWithText(source, suffixText) {
+	const prompt = parsePromptSource(source);
+	const appended = suffixText.trim();
+	if (!appended) return prompt;
+	if (prompt.length === 0) return textPrompt(appended);
+	return [...prompt, ...textPrompt(appended)];
+}
+function promptToDisplayText(prompt) {
+	return prompt.map((block) => contentBlockDisplayText(block)).filter((entry) => entry.trim().length > 0).join("\n\n").trim();
+}
+function contentBlockDisplayText(block) {
+	switch (block.type) {
+		case "text": return block.text;
+		case "resource_link": return block.title ?? block.name ?? block.uri;
+		case "resource": return resourceBlockDisplayText(block);
+		case "image": return `[image] ${block.mimeType}`;
+		case "audio": return `[audio] ${block.mimeType}`;
+		default: return "";
+	}
+}
+function resourceBlockDisplayText(block) {
+	return "text" in block.resource && typeof block.resource.text === "string" ? block.resource.text : block.resource.uri;
+}
+//#endregion
+//#region src/session/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/session/queue/lease-store.ts
+const PROCESS_SIGTERM_GRACE_MS = process.platform === "win32" ? 4e3 : 12e3;
+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") 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,
+		...record.sharedRuntime === true ? { sharedRuntime: true } : {},
+		...record.sessionWatch === true ? { sessionWatch: true } : {},
+		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
+		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
+	};
+}
+function hasValidQueueOwnerRecordFields(record) {
+	return !Array.isArray(record) && 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 cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+	if (!await isCurrent()) return;
+	await removeSocketFile(socketPath).catch(() => {});
+	if (!await isCurrent()) return;
+	await fs$1.unlink(queueLockFilePath(sessionId)).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+}
+async function ownsQueueLease(owner, requireStale = false) {
+	const current = await readQueueOwnerRecord(owner.sessionId);
+	return current?.pid === owner.pid && current.ownerGeneration === owner.ownerGeneration && current.sessionId === owner.sessionId && (!requireStale || !ownerIsAlive(current) || isQueueOwnerHeartbeatStale(current));
+}
+function ownerIsAlive(owner) {
+	return owner.pid === process.pid || isProcessAlive(owner.pid);
+}
+async function readQueueOwnerRecord(sessionId) {
+	const lockPath = queueLockFilePath(sessionId);
+	try {
+		const payload = await fs$1.readFile(lockPath, "utf8");
+		const parsed = parseQueueOwnerRecord(JSON.parse(payload));
+		return parsed?.sessionId === sessionId ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+async function terminateProcess(pid, beforeSignal) {
+	if (!isProcessAlive(pid)) return false;
+	for (const [signal, graceMs] of [["SIGTERM", PROCESS_SIGTERM_GRACE_MS], ["SIGKILL", PROCESS_SIGKILL_GRACE_MS]]) {
+		if (beforeSignal && !await beforeSignal(signal)) return false;
+		try {
+			process.kill(pid, signal);
+		} catch {
+			return false;
+		}
+		if (await waitForProcessExit(pid, graceMs)) return true;
+	}
+	return false;
+}
+async function resolveUsableQueueOwner(sessionId, owner) {
+	if (ownerIsAlive(owner) && !isQueueOwnerHeartbeatStale(owner)) return owner;
+	await terminateQueueOwnerForSession(sessionId, owner, true);
+	const current = await readQueueOwnerRecord(sessionId);
+	return current?.pid === owner.pid && current.ownerGeneration === owner.ownerGeneration && ownerIsAlive(current) && !isQueueOwnerHeartbeatStale(current) ? current : void 0;
+}
+async function readQueueOwnerStatus(sessionId) {
+	const observed = await readQueueOwnerRecord(sessionId);
+	if (!observed) return;
+	const owner = await resolveUsableQueueOwner(sessionId, observed);
+	if (!owner) return;
+	return {
+		pid: owner.pid,
+		socketPath: owner.socketPath,
+		heartbeatAt: owner.heartbeatAt,
+		ownerGeneration: owner.ownerGeneration,
+		queueDepth: owner.queueDepth,
+		alive: true,
+		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 lease = {
+		pid: process.pid,
+		sessionId,
+		lockPath,
+		socketPath,
+		createdAt,
+		ownerGeneration,
+		...mcpConfigMetadata,
+		updates: Promise.resolve(),
+		released: false
+	};
+	try {
+		await stageQueueOwnerRecord(lease, 0, () => createdAt, async (tempPath, payload) => {
+			try {
+				await fs$1.link(tempPath, lockPath);
+			} catch (error) {
+				if (!isHardlinkFallbackError(error)) throw error;
+				await fs$1.writeFile(lockPath, payload, {
+					encoding: "utf8",
+					flag: "wx",
+					mode: 384
+				});
+			}
+		});
+		await removeSocketFile(socketPath).catch(() => {});
+		return lease;
+	} 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 cleanupAbandonedReservation(sessionId);
+		return;
+	}
+	await resolveUsableQueueOwner(sessionId, owner);
+}
+async function cleanupAbandonedReservation(sessionId) {
+	const lockPath = queueLockFilePath(sessionId);
+	try {
+		const observed = await fs$1.lstat(lockPath, { bigint: true });
+		if (!observed.isFile() || Date.now() - Number(observed.mtimeMs) <= QUEUE_OWNER_STALE_HEARTBEAT_MS) return;
+		const raw = await fs$1.readFile(lockPath, "utf8");
+		if (await readQueueOwnerRecord(sessionId)) return;
+		await cleanupQueueOwnerFiles(sessionId, queueSocketPath(sessionId), async () => {
+			const current = await fs$1.lstat(lockPath, { bigint: true });
+			return current.isFile() && current.dev === observed.dev && current.ino === observed.ino && current.mtimeNs === observed.mtimeNs && await fs$1.readFile(lockPath, "utf8") === raw;
+		});
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+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
+	};
+}
+function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
+	if (lease.released) return Promise.resolve();
+	const update = lease.updates.then(async () => {
+		await stageQueueOwnerRecord(lease, options.queueDepth, nowIsoFactory, async (tempPath) => {
+			if (await ownsQueueLease(lease)) await fs$1.rename(tempPath, lease.lockPath);
+		});
+	});
+	lease.updates = update.catch(() => {});
+	return update;
+}
+async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
+	const payload = JSON.stringify({
+		pid: process.pid,
+		sessionId: lease.sessionId,
+		socketPath: lease.socketPath,
+		createdAt: lease.createdAt,
+		heartbeatAt: clock(),
+		ownerGeneration: lease.ownerGeneration,
+		queueDepth: Math.max(0, Math.round(queueDepth)),
+		sharedRuntime: true,
+		sessionWatch: true,
+		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
+		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
+	}, null, 2);
+	await withTempFile({
+		rootDir: path.dirname(lease.lockPath),
+		prefix: "owner",
+		fileName: "lease"
+	}, async (tempPath) => {
+		await fs$1.writeFile(tempPath, `${payload}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		await publish(tempPath, `${payload}\n`);
+	});
+}
+async function releaseQueueOwnerLease(lease) {
+	lease.released = true;
+	await lease.updates;
+	await cleanupQueueOwnerFiles(lease.sessionId, lease.socketPath, () => ownsQueueLease(lease));
+}
+async function terminateQueueOwnerForSession(sessionId, expectedOwner, requireStale = false) {
+	const owner = expectedOwner ?? await readQueueOwnerRecord(sessionId);
+	if (!owner || owner.sessionId !== sessionId) return;
+	if (ownerIsAlive(owner)) await terminateProcess(owner.pid, (signal) => ownsQueueLease(owner, requireStale && signal === "SIGTERM"));
+	if (ownerIsAlive(owner)) return;
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner));
+}
+async function waitMs(ms) {
+	await new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+//#endregion
+//#region src/session/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) {
+	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) {
+		if (!shouldRetryQueueConnect(error)) throw error;
+		await waitMs(50);
+	}
+}
+//#endregion
+//#region src/session/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/session/queue/messages.ts
+function asRecord(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(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(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(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(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(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(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 parseCancelRequest(request, context);
+		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 parseCancelRequest(request, context) {
+	if (request.targetRequestId != null && !parseNonEmptyString(request.targetRequestId)) return null;
+	return {
+		type: "cancel_prompt",
+		requestId: context.requestId,
+		ownerGeneration: context.ownerGeneration,
+		...typeof request.targetRequestId === "string" ? { targetRequestId: request.targetRequestId } : {}
+	};
+}
+function parseSubmitRequest(request, context) {
+	const parsed = parseSubmitRequestFields(request);
+	if (!parsed) return null;
+	return {
+		...parsed,
+		type: "submit_prompt",
+		requestId: context.requestId,
+		ownerGeneration: context.ownerGeneration,
+		prompt: parsed.prompt ?? textPrompt(parsed.message),
+		timeoutMs: context.timeoutMs
+	};
+}
+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,
+		reportPromptStarted: parseOptionalBoolean(request.reportPromptStarted),
+		sessionOptions: parseSessionOptions(request.sessionOptions)
+	};
+	if (Object.values(parsed).some((value) => value === null)) return null;
+	for (const key of [
+		"resumePolicy",
+		"permissionPolicy",
+		"suppressSdkConsoleErrors",
+		"promptRetries",
+		"reportPromptStarted",
+		"sessionOptions"
+	]) if (parsed[key] === void 0) delete parsed[key];
+	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(raw);
+	if (!result || !hasValidSessionSendResultCore(result)) return null;
+	const permissionStats = asRecord(result.permissionStats);
+	const record = asRecord(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(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(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
+	}),
+	prompt_started: (_message, context) => ({
+		type: "prompt_started",
+		...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(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(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/session/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/session/queue/ipc.ts
+const MAX_MESSAGE_BUFFER_SIZE = 10485760;
+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 notifyObserver(notify) {
+	try {
+		notify?.();
+	} catch {}
+}
+function uncertainQueueOutcome(error) {
+	const message = error instanceof Error ? error.message : "Queue request failed";
+	const options = {
+		detailCode: error instanceof QueueProtocolError ? error.detailCode : "QUEUE_SUBMISSION_OUTCOME_UNKNOWN",
+		origin: "queue",
+		retryable: false
+	};
+	return new (error instanceof QueueProtocolError ? QueueProtocolError : QueueConnectionError)(`${message}; request outcome is unknown. Do not automatically resubmit.`, options);
+}
+function emitQueueOwnerError(formatter, policy, sessionId, message) {
+	notifyObserver(() => formatter.setContext({ sessionId }));
+	const queueErrorAlreadyEmitted = policy?.queueErrorAlreadyEmitted ?? true;
+	const shouldEmitInFormatter = message.outputAlreadyEmitted !== true || !queueErrorAlreadyEmitted;
+	if (shouldEmitInFormatter) {
+		notifyObserver(() => formatter.onError({
+			code: message.code ?? "RUNTIME",
+			detailCode: message.detailCode,
+			origin: message.origin ?? "queue",
+			message: message.message,
+			retryable: message.retryable,
+			acp: message.acp
+		}));
+		notifyObserver(() => 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) {
+	options.signal?.throwIfAborted();
+	const requestLine = JSON.stringify(options.request);
+	assertQueueRequestSize(requestLine);
+	const socket = await connectToQueueOwner(options.owner);
+	if (!socket) {
+		options.signal?.throwIfAborted();
+		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;
+			options.signal?.removeEventListener("abort", onAbort);
+			socket.removeAllListeners();
+			if (!socket.destroyed) socket.end();
+			resolve(result);
+		};
+		const finishReject = (error) => {
+			if (settled) return;
+			settled = true;
+			options.signal?.removeEventListener("abort", onAbort);
+			socket.removeAllListeners();
+			if (!socket.destroyed) socket.destroy();
+			reject(error);
+		};
+		const onAbort = () => finishReject(options.signal?.reason);
+		const controls = {
+			state,
+			resolve: finishResolve,
+			reject: finishReject
+		};
+		const processLine = (line) => {
+			let message;
+			try {
+				message = parseQueueOwnerResponseLine(options.owner, options.request.requestId, line);
+			} catch (error) {
+				finishReject(uncertainQueueOutcome(error));
+				return;
+			}
+			if (message.type === "accepted") {
+				state.acknowledged = true;
+				notifyObserver(() => options.onAccepted?.(controls));
+				return;
+			}
+			try {
+				options.onMessage(message, controls);
+			} catch (error) {
+				finishReject(uncertainQueueOutcome(error));
+			}
+		};
+		socket.on("data", (chunk) => {
+			buffer += chunk;
+			if (buffer.length > 10485760) {
+				socket.destroy();
+				finishReject(uncertainQueueOutcome(/* @__PURE__ */ new Error(`Message buffer exceeded ${MAX_MESSAGE_BUFFER_SIZE} bytes`)));
+				return;
+			}
+			let index = buffer.indexOf("\n");
+			while (index >= 0) {
+				if (settled) return;
+				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(uncertainQueueOutcome(error));
+		});
+		socket.once("close", () => {
+			if (settled) return;
+			options.onClose(controls);
+		});
+		options.signal?.addEventListener("abort", onAbort, { once: true });
+		if (options.signal?.aborted) {
+			onAbort();
+			return;
+		}
+		try {
+			socket.write(`${requestLine}\n`);
+		} catch (error) {
+			finishReject(uncertainQueueOutcome(error));
+		}
+	});
+}
+function missingQueueAckError() {
+	return new QueueConnectionError("Queue owner did not acknowledge request; outcome unknown", {
+		detailCode: "QUEUE_ACK_MISSING",
+		origin: "queue",
+		retryable: false
+	});
+}
+function unexpectedQueueResponseError() {
+	return new QueueProtocolError("Queue owner returned unexpected response; outcome unknown", {
+		detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+		origin: "queue",
+		retryable: false
+	});
+}
+function handleAcknowledgedSubmitMessage(message, controls, formatter) {
+	if (message.type === "event") {
+		notifyObserver(() => formatter.onAcpMessage(message.message));
+		return;
+	}
+	if (message.type === "permission_escalation") {
+		notifyObserver(() => formatter.onPermissionEscalation(message.event));
+		return;
+	}
+	if (message.type === "result") {
+		notifyObserver(() => 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;
+	}
+	if (message.type === "prompt_started") {
+		notifyObserver(options.onPromptStarted);
+		return;
+	}
+	handleAcknowledgedSubmitMessage(message, controls, options.outputFormatter);
+}
+async function submitToQueueOwner(owner, options) {
+	const requestId = options.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,
+		...options.onPromptStarted ? { reportPromptStarted: true } : {},
+		sessionOptions: options.sessionOptions
+	};
+	notifyObserver(() => options.outputFormatter.setContext({ sessionId: options.sessionId }));
+	return await runQueueOwnerRequest({
+		owner,
+		request,
+		signal: options.signal,
+		onAccepted: ({ resolve }) => {
+			notifyObserver(options.onQueueAccepted);
+			notifyObserver(() => 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; outcome unknown", {
+					detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+					origin: "queue",
+					retryable: false
+				}));
+				return;
+			}
+			if (!options.waitForCompletion) {
+				resolve({
+					queued: true,
+					sessionId: options.sessionId,
+					requestId
+				});
+				return;
+			}
+			reject(new QueueConnectionError("Queue owner disconnected before prompt completion; outcome unknown", {
+				detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+				origin: "queue",
+				retryable: false
+			}));
+		}
+	});
+}
+async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
+	return await runQueueOwnerRequest({
+		owner,
+		request,
+		onMessage: (message, { state, resolve, reject }) => {
+			if (message.type === "error") {
+				reject(queueConnectionErrorFromOwner(message, false));
+				return;
+			}
+			if (!state.acknowledged) {
+				reject(missingQueueAckError());
+				return;
+			}
+			if (!isExpectedResponse(message)) {
+				reject(unexpectedQueueResponseError());
+				return;
+			}
+			resolve(message);
+		},
+		onClose: ({ state, reject }) => {
+			if (!state.acknowledged) {
+				reject(new QueueConnectionError("Queue owner disconnected before acknowledging request; outcome unknown", {
+					detailCode: "QUEUE_DISCONNECTED_BEFORE_ACK",
+					origin: "queue",
+					retryable: false
+				}));
+				return;
+			}
+			reject(new QueueConnectionError("Queue owner disconnected before responding; outcome unknown", {
+				detailCode: "QUEUE_DISCONNECTED_BEFORE_COMPLETION",
+				origin: "queue",
+				retryable: false
+			}));
+		}
+	});
+}
+async function submitCancelToQueueOwner(owner, targetRequestId) {
+	if (targetRequestId !== void 0) assertSharedRuntimeOwner(owner);
+	return (await submitControlToQueueOwner(owner, {
+		type: "cancel_prompt",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		...targetRequestId !== void 0 ? { targetRequestId } : {}
+	}, (message) => message.type === "cancel_result"))?.cancelled;
+}
+async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
+	return await submitControlToQueueOwner(owner, {
+		type: "set_mode",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		modeId,
+		timeoutMs
+	}, (message) => message.type === "set_mode_result") ? true : void 0;
+}
+async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
+	return await submitControlToQueueOwner(owner, {
+		type: "set_model",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		modelId,
+		timeoutMs
+	}, (message) => message.type === "set_model_result");
+}
+async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
+	return (await submitControlToQueueOwner(owner, {
+		type: "set_config_option",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		configId,
+		value,
+		timeoutMs
+	}, (message) => message.type === "set_config_option_result"))?.response;
+}
+async function submitCloseSessionToQueueOwner(owner, timeoutMs) {
+	return (await submitControlToQueueOwner(owner, {
+		type: "close_session",
+		requestId: randomUUID(),
+		ownerGeneration: owner.ownerGeneration,
+		timeoutMs
+	}, (message) => message.type === "close_session_result"))?.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
+	});
+}
+function assertSharedRuntimeOwner(owner) {
+	if (owner.sharedRuntime === true) return;
+	throw new QueueConnectionError("The running queue owner predates shared runtime support. Wait for its idle expiry or close the session before retrying.", {
+		detailCode: "QUEUE_SHARED_RUNTIME_UNSUPPORTED",
+		origin: "queue",
+		retryable: false
+	});
+}
+async function trySubmitToRunningOwner(options) {
+	options.signal?.throwIfAborted();
+	const observed = await readQueueOwnerRecord(options.sessionId);
+	if (!observed) return;
+	const owner = await resolveUsableQueueOwner(options.sessionId, observed);
+	if (!owner) return;
+	if (options.requireSharedRuntime) assertSharedRuntimeOwner(owner);
+	assertQueueOwnerMcpConfigMatches(owner, options);
+	const submitted = await submitToQueueOwner(owner, options);
+	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 tryControlOnRunningOwner(options) {
+	const owner = await readQueueOwnerRecord(options.sessionId);
+	if (!owner) return;
+	const response = await options.submit(owner);
+	if (response !== void 0) {
+		if (options.verbose) process.stderr.write(`${options.logPrefix} ${owner.pid} for session ${options.sessionId}\n`);
+		return response;
+	}
+	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
+	throw new QueueConnectionError(`Session queue owner is running but not accepting ${options.requestName} requests`, {
+		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function tryCloseSessionOnRunningOwner(options) {
+	return await tryControlOnRunningOwner({
+		sessionId: options.sessionId,
+		verbose: options.verbose,
+		requestName: "close_session",
+		logPrefix: "[acpx] requested session/close on active owner pid",
+		submit: (owner) => submitCloseSessionToQueueOwner(owner, options.timeoutMs)
+	});
+}
+async function tryCancelOnRunningOwner(options) {
+	return await tryControlOnRunningOwner({
+		sessionId: options.sessionId,
+		verbose: options.verbose,
+		requestName: "cancel",
+		logPrefix: "[acpx] requested cancel on active owner pid",
+		submit: (owner) => submitCancelToQueueOwner(owner, options.targetRequestId)
+	});
+}
+async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_mode",
+		logPrefix: "[acpx] requested session/set_mode on owner pid",
+		submit: (owner) => submitSetModeToQueueOwner(owner, modeId, timeoutMs)
+	});
+}
+async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_model",
+		logPrefix: "[acpx] requested a model config update on owner pid",
+		submit: (owner) => submitSetModelToQueueOwner(owner, modelId, timeoutMs)
+	});
+}
+async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_config_option",
+		logPrefix: "[acpx] requested session/set_config_option on owner pid",
+		submit: (owner) => submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs)
+	});
+}
+//#endregion
+export { startPerfTimer as $, listSessions as A, AgentSpawnError as At, extractAgentSessionId as B, SessionModeReplayError as Bt, textPrompt as C, OUTPUT_ERROR_ORIGINS as Ct, findSession as D, SESSION_RECORD_SCHEMA as Dt, findGitRepositoryRoot as E, PERMISSION_POLICY_ACTIONS as Et, resolveSessionRecord as F, GeminiAcpStartupTimeoutError as Ft, watchSession as G, SESSION_JOURNAL_SCHEMA as H, SessionNotFoundError as Ht, writeSessionRecord as I, PermissionDeniedError as It, incrementPerfCounter as J, formatPerfMetric as K, assertPersistedKeyPolicy as L, PermissionPromptUnavailableError as Lt, normalizeName as M, AuthPolicyError as Mt, pruneSessions as N, ClaudeAcpSessionCreateTimeoutError as Nt, findSessionByDirectoryWalk as O, AcpxOperationalError as Ot, readSessionRecord as P, CopilotAcpUnsupportedError as Pt, setPerfGauge as Q, parseSessionRecord as R, QueueConnectionError as Rt, promptToDisplayText as S, OUTPUT_ERROR_CODES as St, absolutePath as T, PERMISSION_MODES as Tt, SessionJournalReader as U, SessionResumeRequiredError as Ut, normalizeAgentSessionId as V, SessionModelReplayError as Vt, SessionWatchError as W, UnsupportedPromptContentError as Wt, recordPerfDuration as X, measurePerf as Y, resetPerfMetrics as Z, waitMs as _, formatUnknownErrorMessage as _t, trySetModelOnRunningOwner as a, parsePermissionNotice as at, mergePromptSourceWithText as b, EXIT_CODES as bt, queueRequestExceedsLimit as c, defaultSessionEventLog as ct, readQueueOwnerRecord as d, sessionEventLockPath as dt, extractSessionUpdateNotification as et, refreshQueueOwnerLease as f, sessionEventSegmentPath as ft, tryAcquireQueueOwnerLease as g, extractAcpError as gt, terminateQueueOwnerForSession as h, isProcessAlive as ht, trySetModeOnRunningOwner as i, parseJsonRpcErrorMessage as it, listSessionsForAgent as j, AgentStartupError as jt, isoNow as k, AgentDisconnectedError as kt, parseQueueRequest as l, sessionBaseDir as lt, terminateProcess as m, writePrivateJsonFile as mt, tryCloseSessionOnRunningOwner as n, isAcpMessageObject as nt, trySubmitToRunningOwner as o, parsePromptStopReason as ot, releaseQueueOwnerLease as p, writePrivateFile as pt, getPerfMetricsSnapshot as q, trySetConfigOptionOnRunningOwner as r, isSessionUpdateNotification as rt, queueRequestByteLimit as s, DEFAULT_EVENT_SEGMENT_MAX_BYTES as st, tryCancelOnRunningOwner as t, isAcpJsonRpcMessage as tt, probeQueueOwnerHealth as u, sessionEventActivePath as ut, PromptInputValidationError as v, isAcpResourceNotFoundError as vt, DEFAULT_HISTORY_LIMIT as w, OUTPUT_FORMATS as wt, parsePromptSource as x, NON_INTERACTIVE_PERMISSION_POLICIES as xt, getUnsupportedPromptContentMessage as y, AUTH_POLICIES as yt, serializeSessionRecordForDisk as z, SessionConfigOptionReplayError as zt };
+
+//# sourceMappingURL=ipc-D3akHMEq.js.map