acpx 0.19.2 → 0.19.4

package/dist/{queue-owner-runtime-W0lly6ap.js → queue-owner-runtime-C0wIYowh.js}

@@ -1,5 +1,5 @@
-import { $ as resetPerfMetrics, Bt as PermissionDeniedError, Ct as extractAcpError, E as textPrompt, F as normalizeName, Ft as AgentStartupError, G as SESSION_JOURNAL_SCHEMA, Gt as SessionModelReplayError, Ht as QueueConnectionError, It as AuthPolicyError, Jt as UnsupportedPromptContentError, K as SessionJournalReader, Lt as ClaudeAcpSessionCreateTimeoutError, M as isoNow$1, Mt as AcpxOperationalError, Nt as AgentDisconnectedError, O as absolutePath, Pt as AgentSpawnError, Q as measurePerf, R as resolveSessionRecord, Rt as CopilotAcpUnsupportedError, S as getUnsupportedPromptContentMessage, St as normalizeOutputError, T as promptToDisplayText, U as extractAgentSessionId, Ut as SessionConfigOptionReplayError, Vt as PermissionPromptUnavailableError, W as normalizeAgentSessionId, Wt as SessionModeReplayError, X as getPerfMetricsSnapshot, Y as formatPerfMetric, Z as incrementPerfCounter, _ as createLockOwner, _t as isProcessAlive, a as trySetModelOnRunningOwner, at as isSessionUpdateNotification, bt as isAcpQueryClosedBeforeResponseError, d as releaseQueueOwnerLease, dt as sessionBaseDir, et as setPerfGauge, f as terminateProcess, ft as sessionEventActivePath, g as QueueLeaseGuardSettlementError, h as waitMs$1, i as trySetModeOnRunningOwner, it as isAcpMessageObject, j as findSessionByDirectoryWalk, k as findGitRepositoryRoot, m as tryAcquireQueueOwnerLease, mt as sessionEventSegmentPath, n as tryCloseSessionOnRunningOwner, o as trySubmitToRunningOwner, p as terminateQueueOwnerForSession, pt as sessionEventLockPath, qt as SessionResumeRequiredError, r as trySetConfigOptionOnRunningOwner, rt as isAcpJsonRpcMessage, s as SessionQueueOwner, t as tryCancelOnRunningOwner, tt as startPerfTimer, u as refreshQueueOwnerLease, ut as defaultSessionEventLog, v as lockOwnerPid, wt as isAcpResourceNotFoundError, xt as isRetryablePromptError, y as ProcessDescendants, yt as formatErrorMessage, z as writeSessionRecord, zt as GeminiAcpStartupTimeoutError } from "./ipc-D0ZMQ0q9.js";
-import { A as requireAgentStdio, C as PROCESS_HELPER_TIMEOUT_MS, D as isoNow$2, E as isChildProcessRunning, F as waitForChildExit, I as waitForSpawn, M as resolveAgentSessionCwd, N as runTimedExecFile, P as splitCommandLine, T as basenameToken, _ as buildSpawnCommandOptions, b as readWindowsEnvValue, f as resolveBuiltInAgentLaunch, g as buildAgentSpawnCommand, j as resolveAgentCommandParts, v as buildTerminalShellSpawnCommand, w as asAbsoluteCwd, x as resolveWindowsExecutablePath, y as buildTerminalSpawnCommand } from "./agent-registry-DWlx5BQ4.js";
+import { $ as resetPerfMetrics, Bt as GeminiAcpStartupTimeoutError, C as textPrompt, Ct as normalizeOutputError, F as normalizeName, Ft as AgentSpawnError, G as SESSION_JOURNAL_SCHEMA, Gt as SessionModeReplayError, Ht as PermissionPromptUnavailableError, It as AgentStartupError, Jt as SessionResumeRequiredError, K as SessionJournalReader, Kt as SessionModelReplayError, L as readSessionRecord, Lt as AuthPolicyError, M as isoNow$1, Nt as AcpxOperationalError, O as absolutePath, Pt as AgentDisconnectedError, Q as measurePerf, R as resolveSessionRecord, Rt as ClaudeAcpSessionCreateTimeoutError, S as promptToDisplayText, St as isRetryablePromptError, T as lockOwnerPid, Tt as isAcpResourceNotFoundError, U as extractAgentSessionId, Ut as QueueConnectionError, Vt as PermissionDeniedError, W as normalizeAgentSessionId, Wt as SessionConfigOptionReplayError, X as getPerfMetricsSnapshot, Y as formatPerfMetric, Yt as UnsupportedPromptContentError, Z as incrementPerfCounter, _ as ProcessDescendants, a as trySetModelOnRunningOwner, at as isSessionUpdateNotification, bt as formatErrorMessage, d as releaseQueueOwnerLease, dt as sessionBaseDir, et as setPerfGauge, f as terminateProcess, ft as sessionEventActivePath, g as QueueLeaseGuardSettlementError, h as waitMs$1, i as trySetModeOnRunningOwner, it as isAcpMessageObject, j as findSessionByDirectoryWalk, k as findGitRepositoryRoot, m as tryAcquireQueueOwnerLease, mt as sessionEventSegmentPath, n as tryCloseSessionOnRunningOwner, o as trySubmitToRunningOwner, p as terminateQueueOwnerForSession, pt as sessionEventLockPath, r as trySetConfigOptionOnRunningOwner, rt as isAcpJsonRpcMessage, s as SessionQueueOwner, t as tryCancelOnRunningOwner, tt as startPerfTimer, u as refreshQueueOwnerLease, ut as defaultSessionEventLog, vt as isProcessAlive, w as createLockOwner, wt as extractAcpError, xt as isAcpQueryClosedBeforeResponseError, y as getUnsupportedPromptContentMessage, z as writeSessionRecord, zt as CopilotAcpUnsupportedError } from "./ipc-D7zT86b9.js";
+import { A as requireAgentStdio, C as PROCESS_HELPER_TIMEOUT_MS, D as isoNow$2, E as isChildProcessRunning, F as waitForChildExit, I as waitForSpawn, M as resolveAgentSessionCwd, N as runTimedExecFile, P as splitCommandLine, T as basenameToken, _ as buildSpawnCommandOptions, b as readWindowsEnvValue, f as resolveBuiltInAgentLaunch, g as buildAgentSpawnCommand, j as resolveAgentCommandParts, v as buildTerminalShellSpawnCommand, w as asAbsoluteCwd, x as resolveWindowsExecutablePath, y as buildTerminalSpawnCommand } from "./agent-registry-kHdpsK9F.js";
 import fs, { readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
@@ -8,14 +8,14 @@ import fs$1 from "node:fs/promises";
 import { appendRegularFile, appendRegularFileSync, withTempFile } from "@openclaw/fs-safe/advanced";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import { createHash, randomUUID } from "node:crypto";
+import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
+import { acquireFileLock } from "@openclaw/fs-safe/file-lock";
 import { Readable, Writable } from "node:stream";
 import { PROTOCOL_VERSION, RequestError, client, methods } from "@agentclientprotocol/sdk";
 import { FsSafeError } from "@openclaw/fs-safe/errors";
 import { isPathInside } from "@openclaw/fs-safe/path";
 import { root } from "@openclaw/fs-safe/root";
 import readline from "node:readline/promises";
-import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
-import { acquireFileLock } from "@openclaw/fs-safe/file-lock";
 //#region src/async-control.ts
 var TimeoutError = class extends Error {
 	constructor(timeoutMs) {
@@ -346,6 +346,246 @@ async function listSessionEvents(sessionId, maxSegments) {
 	}).readAcpMessages();
 }
 //#endregion
+//#region src/session/turn-ownership.ts
+const LOCK_RETRY_MS = 15;
+const INCOMPLETE_RESERVATION_GRACE_MS = 15e3;
+let lastCreatedAt = 0;
+const localTurns = /* @__PURE__ */ new Map();
+async function readLock(filePath) {
+	try {
+		const stat = await fs$1.lstat(filePath, { bigint: true });
+		if (!stat.isFile()) throw new Error(`Session turn lock is not a regular file: ${filePath}`);
+		return {
+			stat,
+			payload: await fs$1.readFile(filePath, "utf8")
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+function parseLock(payload) {
+	try {
+		return JSON.parse(payload);
+	} catch {
+		return;
+	}
+}
+async function tryAcquireGuard(filePath, owner, signal) {
+	try {
+		return await acquireFileLock(filePath, {
+			managerKey: "acpx.session-turn",
+			lockPath: `${filePath}.guard`,
+			staleMs: Infinity,
+			timeoutMs: LOCK_RETRY_MS,
+			retry: {
+				retries: 8,
+				minTimeout: 1,
+				maxTimeout: 2,
+				factor: 1,
+				randomize: false
+			},
+			staleRecovery: "remove-if-unchanged",
+			payload: () => owner.payload,
+			shouldReclaim: ({ payload }) => owner.hasExited(payload, false, signal),
+			shouldRemoveStaleLock: ({ payload }) => owner.hasExited(payload, true, signal)
+		});
+	} catch (error) {
+		if (error.code === "file_lock_timeout") return;
+		throw error;
+	}
+}
+async function removeObservedLock(filePath, observed) {
+	const current = await readLock(filePath);
+	if (!current) return true;
+	if (current.payload !== observed.payload || current.stat.mtimeNs !== observed.stat.mtimeNs || current.stat.size !== observed.stat.size) return false;
+	await fs$1.unlink(filePath).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+	return true;
+}
+async function recoverAbandonedLock(filePath, owner, signal) {
+	const observed = await readLock(filePath);
+	if (!observed) return true;
+	const payload = parseLock(observed.payload);
+	const pid = lockOwnerPid(payload);
+	if (pid && (!await owner.hasExited(payload, false, signal) || !await owner.hasExited(payload, true, signal))) return false;
+	if (!pid && Date.now() - Number(observed.stat.mtimeMs) <= INCOMPLETE_RESERVATION_GRACE_MS) return false;
+	if (await removeObservedLock(filePath, observed)) {
+		incrementPerfCounter("session.events.stale_lock_recovered");
+		return true;
+	}
+	return false;
+}
+async function publishLock(filePath, payload, signal) {
+	await withTempFile({
+		rootDir: path.dirname(filePath),
+		prefix: "session-turn",
+		fileName: "lock"
+	}, async (temporaryPath) => {
+		await fs$1.writeFile(temporaryPath, payload, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		signal?.throwIfAborted();
+		try {
+			await fs$1.link(temporaryPath, filePath);
+		} catch (error) {
+			if (!isHardlinkFallbackError(error)) throw error;
+			await fs$1.writeFile(filePath, payload, {
+				encoding: "utf8",
+				flag: "wx",
+				mode: 384
+			});
+		}
+	});
+}
+async function removePublishedLock(filePath, payload) {
+	const current = await readLock(filePath);
+	if (current?.payload === payload) await removeObservedLock(filePath, current);
+}
+async function rejectAcquisition(filePath, receipt, error) {
+	const failures = [error];
+	await disposeTurn(filePath, receipt).catch((cleanupError) => {
+		failures.push(...cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError]);
+	});
+	if (failures.length > 1) throw new AggregateError(failures, "Session turn acquisition and cleanup failed");
+	throw error;
+}
+async function releaseTurnGuard(receipt) {
+	await receipt.guard?.release();
+	receipt.guard = void 0;
+}
+async function removeTurnMarker(filePath, receipt) {
+	if (!receipt.removeMarker) return true;
+	if (receipt.guard && !await receipt.guard.verifyStillHeld()) await releaseTurnGuard(receipt);
+	receipt.guard ??= await tryAcquireGuard(filePath, receipt.owner);
+	if (!receipt.guard) return false;
+	await receipt.removeMarker();
+	receipt.removeMarker = void 0;
+	return true;
+}
+async function settleTurn(filePath, receipt) {
+	if (receipt.settled) return true;
+	const pending = receipt.pending ??= (async () => {
+		receipt.failed = false;
+		const failures = [];
+		try {
+			if (!await removeTurnMarker(filePath, receipt)) return false;
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length === 0 || !receipt.admitted) try {
+			await releaseTurnGuard(receipt);
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length > 1) throw new AggregateError(failures, "Session turn cleanup failed");
+		if (failures.length === 1) throw failures[0];
+		receipt.settled = true;
+		localTurns.delete(filePath);
+		return true;
+	})();
+	try {
+		return await pending;
+	} finally {
+		if (receipt.pending === pending) {
+			receipt.pending = void 0;
+			receipt.failed = !receipt.settled;
+		}
+	}
+}
+async function disposeTurn(filePath, receipt) {
+	if (!await settleTurn(filePath, receipt)) throw new Error(`Session turn cleanup is waiting for its guard: ${filePath}`);
+}
+async function tryPublishLock(filePath, payload, owner, signal) {
+	for (;;) try {
+		await publishLock(filePath, payload, signal);
+		return true;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		if (!await recoverAbandonedLock(filePath, owner, signal)) return false;
+	}
+}
+async function tryAcquireTurnCleanup(filePath, payload, owner, signal) {
+	const previous = localTurns.get(filePath);
+	if (previous) {
+		if (previous.failed) await settleTurn(filePath, previous);
+		return;
+	}
+	const receipt = {
+		owner,
+		removeMarker: async () => await removePublishedLock(filePath, payload),
+		admitted: false,
+		failed: false,
+		settled: false
+	};
+	localTurns.set(filePath, receipt);
+	try {
+		receipt.guard = await tryAcquireGuard(filePath, owner, signal);
+	} catch (error) {
+		localTurns.delete(filePath);
+		throw error;
+	}
+	if (!receipt.guard) {
+		localTurns.delete(filePath);
+		return;
+	}
+	return receipt;
+}
+async function tryAcquireTurn(filePath, payload, owner, signal) {
+	const receipt = await tryAcquireTurnCleanup(filePath, payload, owner, signal);
+	if (!receipt) return;
+	try {
+		signal?.throwIfAborted();
+		if (!await tryPublishLock(filePath, payload, owner, signal)) {
+			await disposeTurn(filePath, receipt);
+			return;
+		}
+		const observed = await readLock(filePath);
+		if (observed?.payload !== payload) throw new Error(`Session turn ownership changed before admission: ${filePath}`);
+		signal?.throwIfAborted();
+		receipt.admitted = true;
+		receipt.removeMarker = async () => await removeObservedLock(filePath, observed);
+		return { [Symbol.asyncDispose]: async () => await disposeTurn(filePath, receipt) };
+	} catch (error) {
+		return await rejectAcquisition(filePath, receipt, error);
+	}
+}
+async function acquireSessionTurn(recordId, signal) {
+	return await acquireSessionOwnership(sessionEventLockPath(recordId), signal);
+}
+async function acquireSessionScope(scope, signal) {
+	return await acquireSessionTurn(`ensure:${createHash("sha256").update(JSON.stringify([
+		scope.agentCommand,
+		scope.cwd,
+		scope.name
+	])).digest("hex")}`, signal);
+}
+async function acquireSessionImport(signal) {
+	return await acquireSessionOwnership(path.join(sessionBaseDir(), ".import-admission.lock"), signal);
+}
+async function acquireSessionOwnership(requestedPath, signal) {
+	await fs$1.mkdir(path.dirname(requestedPath), {
+		recursive: true,
+		mode: 448
+	});
+	const filePath = path.join(await fs$1.realpath(path.dirname(requestedPath)), path.basename(requestedPath));
+	const owner = await createLockOwner({ signal });
+	lastCreatedAt = Math.max(Date.now(), lastCreatedAt + 1);
+	const payload = `${JSON.stringify({
+		...owner.payload,
+		created_at: new Date(lastCreatedAt).toISOString()
+	}, null, 2)}\n`;
+	for (;;) {
+		signal?.throwIfAborted();
+		const turn = await tryAcquireTurn(filePath, payload, owner, signal);
+		if (turn) return turn;
+		await setTimeout$1(LOCK_RETRY_MS, void 0, { signal });
+	}
+}
+//#endregion
 //#region src/session/execution/contracts.ts
 const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
 function normalizeQueueOwnerTtlMs(ttlMs) {
@@ -366,6 +606,18 @@ function sliceReadWindow(content, line, limit) {
 }
 //#endregion
 //#region src/permission-prompt.ts
+function visiblePromptText(value) {
+	let rendered = "";
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint !== void 0 && (codePoint <= 31 || codePoint >= 127 && codePoint <= 159)) {
+			rendered += `\\x${codePoint.toString(16).padStart(2, "0")}`;
+			continue;
+		}
+		rendered += character;
+	}
+	return rendered;
+}
 let promptQueue = Promise.resolve();
 async function promptForPermission(options) {
 	options.signal?.throwIfAborted();
@@ -384,6 +636,10 @@ async function promptForPermission(options) {
 		signal.removeEventListener("abort", onAbort);
 	}
 }
+function promptForDisplay(prompt) {
+	if (prompt.startsWith("\n")) return `\n${visiblePromptText(prompt.slice(1))}`;
+	return visiblePromptText(prompt);
+}
 async function askPermission(options) {
 	options.signal?.throwIfAborted();
 	if (!canPrompt()) return false;
@@ -400,7 +656,7 @@ async function askPermission(options) {
 		rl.once("close", onClose);
 	});
 	try {
-		const answer = await Promise.race([rl.question(options.prompt, { signal }), closed]);
+		const answer = await Promise.race([rl.question(promptForDisplay(options.prompt), { signal }), closed]);
 		options.signal?.throwIfAborted();
 		const normalized = answer?.trim().toLowerCase();
 		return normalized === "y" || normalized === "yes";
@@ -414,8 +670,8 @@ function canPrompt() {
 	return process.stdin.isTTY && process.stderr.isTTY && !process.stdin.readableEnded && !process.stdin.destroyed;
 }
 function writePromptDetails(options) {
-	if (options.header) process.stderr.write(`\n${options.header}\n`);
-	if (options.details && options.details.trim().length > 0) process.stderr.write(`${options.details}\n`);
+	if (options.header) process.stderr.write(`\n${visiblePromptText(options.header)}\n`);
+	if (options.details && options.details.trim().length > 0) process.stderr.write(`${options.details.split("\n").map(visiblePromptText).join("\n")}\n`);
 }
 //#endregion
 //#region src/filesystem.ts
@@ -1016,10 +1272,10 @@ function assignClaudeCodeSystemPrompt(target, systemPrompt) {
 function isAppendSystemPrompt(value) {
 	return !!value && typeof value === "object" && typeof value.append === "string" && value.append.length > 0;
 }
-function resolveClaudeCodeExecutable(platform = process.platform, env = process.env) {
+function resolveClaudeCodeExecutable(platform = process.platform, env = process.env, cwd) {
 	if (platform !== "win32") return;
 	if (readWindowsEnvValue(env, "CLAUDE_CODE_EXECUTABLE")) return;
-	return resolveWindowsExecutablePath("claude", env);
+	return resolveWindowsExecutablePath("claude", env, cwd);
 }
 //#endregion
 //#region src/acp/auth-env.ts
@@ -1066,7 +1322,7 @@ function promotePrefixedAuthEnvironment(env) {
 		if (!normalized) continue;
 		protectEnvKey(protectedKeys, key);
 		protectEnvKey(protectedKeys, normalized);
-		if (env[normalized] == null) env[normalized] = value;
+		assignIfMissing(env, normalized, value);
 	}
 	return protectedKeys;
 }
@@ -1090,7 +1346,12 @@ function buildAgentEnvironment(authCredentials, sessionEnv, agentProcessEnv) {
 function assignSessionEnv(env, key, value) {
 	const normalizedKey = protectedEnvKey(key);
 	for (const existingKey of Object.keys(env)) if (protectedEnvKey(existingKey) === normalizedKey) delete env[existingKey];
-	env[key] = value;
+	Object.defineProperty(env, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
 }
 function addAuthCredentialEnvKeys(protectedKeys, methodId, credential) {
 	if (typeof credential !== "string" || credential.trim().length === 0) return;
@@ -1103,7 +1364,7 @@ function addAuthCredentialEnvKeys(protectedKeys, methodId, credential) {
 }
 function assignAuthCredentialEnv(env, methodId, credential) {
 	if (typeof credential !== "string" || credential.trim().length === 0) return;
-	if (!methodId.includes("=") && !methodId.includes("\0") && env[methodId] == null) env[methodId] = credential;
+	if (!methodId.includes("=") && !methodId.includes("\0")) assignIfMissing(env, methodId, credential);
 	const normalized = toEnvToken(methodId);
 	if (normalized) {
 		assignIfMissing(env, `${AUTH_ENV_PREFIX}${normalized}`, credential);
@@ -1111,7 +1372,10 @@ function assignAuthCredentialEnv(env, methodId, credential) {
 	}
 }
 function assignIfMissing(env, key, value) {
-	if (env[key] == null) env[key] = value;
+	if (env[key] != null) return;
+	const normalizedKey = protectedEnvKey(key);
+	if (process.platform === "win32" && Object.entries(env).some(([existingKey, existingValue]) => existingValue != null && protectedEnvKey(existingKey) === normalizedKey)) return;
+	env[key] = value;
 }
 function resolveConfiguredAuthCredential(methodId, authCredentials) {
 	const configCredentials = authCredentials ?? {};
@@ -1273,34 +1537,7 @@ function captureCommandProbeOutput(child, timeoutMs, retire) {
 	};
 }
 //#endregion
-//#region src/acp/model-support.ts
-const REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE = "ACP_MODEL_UNSUPPORTED";
-const REQUESTED_MODEL_UNSUPPORTED_REASONS = ["missing-capability", "unadvertised-model"];
-var RequestedModelUnsupportedError = class extends Error {
-	code = REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE;
-	reason;
-	ambiguous;
-	constructor(message, reason, details) {
-		super(message);
-		this.name = "RequestedModelUnsupportedError";
-		this.reason = reason;
-		if (details?.ambiguous) this.ambiguous = true;
-	}
-};
-function isRequestedModelUnsupportedReason(value) {
-	return typeof value === "string" && REQUESTED_MODEL_UNSUPPORTED_REASONS.includes(value);
-}
-function isRequestedModelUnsupportedError(value) {
-	if (value instanceof RequestedModelUnsupportedError) return true;
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return candidate.name === "RequestedModelUnsupportedError" && candidate.code === "ACP_MODEL_UNSUPPORTED" && isRequestedModelUnsupportedReason(candidate.reason);
-}
-function supportsLegacyClaudeCodeModelMetadata(agentCommand) {
-	if (!agentCommand) return false;
-	const { command, args } = splitCommandLine(agentCommand);
-	return isClaudeAcpCommand(command, args);
-}
+//#region src/acp/model-config-state.ts
 function asRecord$2(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
@@ -1359,6 +1596,35 @@ function modelStateFromConfigOptions(configOptions) {
 	}
 	return selected;
 }
+//#endregion
+//#region src/acp/model-support.ts
+const REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE = "ACP_MODEL_UNSUPPORTED";
+const REQUESTED_MODEL_UNSUPPORTED_REASONS = ["missing-capability", "unadvertised-model"];
+var RequestedModelUnsupportedError = class extends Error {
+	code = REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE;
+	reason;
+	ambiguous;
+	constructor(message, reason, details) {
+		super(message);
+		this.name = "RequestedModelUnsupportedError";
+		this.reason = reason;
+		if (details?.ambiguous) this.ambiguous = true;
+	}
+};
+function isRequestedModelUnsupportedReason(value) {
+	return typeof value === "string" && REQUESTED_MODEL_UNSUPPORTED_REASONS.includes(value);
+}
+function isRequestedModelUnsupportedError(value) {
+	if (value instanceof RequestedModelUnsupportedError) return true;
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return candidate.name === "RequestedModelUnsupportedError" && candidate.code === "ACP_MODEL_UNSUPPORTED" && isRequestedModelUnsupportedReason(candidate.reason);
+}
+function supportsLegacyClaudeCodeModelMetadata(agentCommand) {
+	if (!agentCommand) return false;
+	const { command, args } = splitCommandLine(agentCommand);
+	return isClaudeAcpCommand(command, args);
+}
 function modelStateFromLegacyResponse(response) {
 	if (!response || typeof response !== "object") return;
 	const models = response.models;
@@ -1390,6 +1656,16 @@ function resolveRequestedModelId(params) {
 	if (candidates.length > 1) throw new RequestedModelUnsupportedError(`Cannot select model "${params.requestedModel}": multiple advertised Cursor models match (${candidates.join(", ")}). Use an exact advertised model ID.`, "unadvertised-model", { ambiguous: true });
 	return candidates.length === 1 ? candidates[0] : params.requestedModel;
 }
+function resolveRequestedConfigOption(params) {
+	const modelConfigId = params.models?.configId;
+	return {
+		modelConfigId,
+		resolvedValue: modelConfigId === params.configId ? resolveRequestedModelId({
+			...params,
+			requestedModel: params.value
+		}) : params.value
+	};
+}
 function isCursorAcpCommandForModelAlias(agentCommand) {
 	if (!agentCommand) return false;
 	const { command, args } = splitCommandLine(agentCommand);
@@ -1622,7 +1898,7 @@ function buildTerminalSpawnOptions(command, cwd, env, platform = process.platfor
 			"pipe"
 		],
 		windowsHide: true
-	}, platform, resolvedEnv ?? process.env);
+	}, platform, resolvedEnv ?? process.env, cwd);
 }
 function readTerminalOutputCeiling() {
 	const raw = process.env.ACPX_TERMINAL_MAX_OUTPUT_BYTES?.trim();
@@ -1673,6 +1949,7 @@ var TerminalManager = class {
 	processHelperTimeoutMs;
 	outputCeilingBytes;
 	terminals = /* @__PURE__ */ new Map();
+	creations = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.outputCeilingBytes = readTerminalOutputCeiling();
 		this.cwd = options.cwd;
@@ -1689,7 +1966,15 @@ var TerminalManager = class {
 		this.permissionMode = permissionMode;
 		this.nonInteractivePermissions = nonInteractivePermissions ?? "deny";
 	}
-	async createTerminal(params, authority) {
+	createTerminal(params, authority) {
+		const creation = {};
+		const pending = Promise.resolve().then(() => this.create(params, authority, creation));
+		this.creations.set(pending, creation);
+		const remove = () => this.creations.delete(pending);
+		pending.then(remove, remove);
+		return pending;
+	}
+	async create(params, authority, creation) {
 		assertControlAuthority(authority);
 		const commandLine = toCommandLine(params.command, params.args);
 		const summary = `terminal/create: ${commandLine}`;
@@ -1753,10 +2038,15 @@ var TerminalManager = class {
 				await terminal.descendants?.capture(terminal.processHelperTimeoutMs);
 				assertControlAuthority(authority);
 			} catch (error) {
-				await this.releaseTerminal({
-					terminalId,
-					sessionId: params.sessionId
-				});
+				try {
+					await this.releaseTerminal({
+						terminalId,
+						sessionId: params.sessionId
+					});
+				} catch (cleanupError) {
+					creation.cleanupFailure = { error: cleanupError };
+					throw cleanupError;
+				}
 				throw error;
 			}
 			this.emitOperation({
@@ -1889,11 +2179,13 @@ var TerminalManager = class {
 		}
 	}
 	async shutdown() {
+		const creations = [...this.creations];
+		await Promise.allSettled(creations.map(([pending]) => pending));
 		const results = await Promise.allSettled(Array.from(this.terminals.keys(), (terminalId) => this.releaseTerminal({
 			terminalId,
 			sessionId: "shutdown"
 		})));
-		const failures = [];
+		const failures = creations.flatMap(([, creation]) => creation.cleanupFailure ? [creation.cleanupFailure.error] : []);
 		for (const result of results) if (result.status === "rejected") failures.push(result.reason);
 		if (failures.length > 0) throw new AggregateError(failures, "Terminal shutdown failed", { cause: failures[0] });
 	}
@@ -1983,7 +2275,7 @@ async function spawnTerminalProcess(params, defaultCwd, authority) {
 }
 async function spawnAndWait(spawnCommand, params, defaultCwd, authority) {
 	const spawnOptions = buildTerminalSpawnOptions(spawnCommand.command, params.cwd ?? defaultCwd, params.env);
-	if (spawnCommand.killProcessGroup || process.platform !== "win32") spawnOptions.detached = true;
+	if (process.platform !== "win32") spawnOptions.detached = true;
 	assertControlAuthority(authority);
 	const proc = spawn(spawnCommand.command, spawnCommand.args, spawnOptions);
 	await waitForSpawn(proc);
@@ -2147,7 +2439,14 @@ function hasResponseField(response, field) {
 }
 function normalizeResponseConfigOptions(response) {
 	if (!response || !("configOptions" in response)) return;
-	return response.configOptions ?? [];
+	return Array.isArray(response.configOptions) ? response.configOptions : void 0;
+}
+function normalizeConfigOptionAcknowledgement(response) {
+	if (!response || typeof response !== "object" || Array.isArray(response)) return {};
+	if (Array.isArray(response.configOptions)) return response;
+	const acknowledgement = { ...response };
+	delete acknowledgement.configOptions;
+	return acknowledgement;
 }
 function toReconnectedSessionResult(response) {
 	const configOptions = normalizeResponseConfigOptions(response);
@@ -2158,7 +2457,7 @@ function toReconnectedSessionResult(response) {
 			configOptions,
 			response
 		}),
-		configOptionsPresent: hasResponseField(response, "configOptions"),
+		configOptionsPresent: configOptions !== void 0,
 		legacyModelMetadataPresent: hasResponseField(response, "models")
 	};
 }
@@ -2337,8 +2636,9 @@ var AcpClient = class {
 		}
 		fallback?.abort();
 	}
-	async start(authority) {
+	async start(authority, options) {
 		assertControlAuthority(authority);
+		if (options) this.options.sessionOptions = structuredClone(options.sessionOptions);
 		if (this.hasLiveConnection()) return;
 		const epoch = await this.waitForPreviousClose();
 		const maxMessageBytes = readMaxAcpMessageBytes();
@@ -2457,14 +2757,14 @@ var AcpClient = class {
 	async ensureLaunchSupport(plan) {
 		if (plan.copilotAcp) await ensureCopilotAcpSupport(plan.spawnCommand, plan.commandContext);
 		if (!plan.claudeAcp) return;
-		const claudeExe = resolveClaudeCodeExecutable(process.platform, plan.spawnOptions.env);
+		const claudeExe = resolveClaudeCodeExecutable(process.platform, plan.spawnOptions.env, plan.spawnOptions.cwd);
 		if (claudeExe) {
 			plan.spawnOptions.env.CLAUDE_CODE_EXECUTABLE = claudeExe;
 			this.log(`resolved system Claude Code executable: ${claudeExe}`);
 		}
 	}
 	prepareProcessLaunch(command, args, options) {
-		const resolved = buildAgentSpawnCommand(command, args, process.platform, options.env);
+		const resolved = buildAgentSpawnCommand(command, args, process.platform, options.env, options.cwd);
 		return {
 			launch: Object.freeze({
 				launchId: randomUUID(),
@@ -2674,6 +2974,10 @@ var AcpClient = class {
 			onPromptRequestWritten: (active, owner) => this.onPromptRequestWritten(active, owner)
 		});
 	}
+	sessionMeta() {
+		const { command, args } = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
+		return buildClaudeCodeOptionsMeta(this.options.sessionOptions, isClaudeAcpCommand(command, args));
+	}
 	async createSession(cwd = this.options.cwd, authority) {
 		assertControlAuthority(authority);
 		const connection = this.getConnection();
@@ -2685,7 +2989,7 @@ var AcpClient = class {
 			const createPromise = this.runConnectionRequest(() => connection.agent.request(methods.agent.session.new, {
 				cwd: sessionCwd,
 				mcpServers: this.options.mcpServers ?? [],
-				_meta: buildClaudeCodeOptionsMeta(this.options.sessionOptions, claudeAcp)
+				_meta: this.sessionMeta()
 			}), authority);
 			result = claudeAcp ? await withTimeout(createPromise, resolveClaudeAcpSessionCreateTimeoutMs()) : await createPromise;
 		} catch (error) {
@@ -2707,7 +3011,7 @@ var AcpClient = class {
 			agentSessionId: extractAgentSessionId(result._meta),
 			configOptions,
 			models,
-			configOptionsPresent: hasResponseField(result, "configOptions"),
+			configOptionsPresent: configOptions !== void 0,
 			legacyModelMetadataPresent: hasResponseField(result, "models")
 		};
 	}
@@ -2725,7 +3029,8 @@ var AcpClient = class {
 			response = await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.load, {
 				sessionId,
 				cwd: sessionCwd,
-				mcpServers: this.options.mcpServers ?? []
+				mcpServers: this.options.mcpServers ?? [],
+				_meta: this.sessionMeta()
 			}), options.authority);
 			await this.waitForSessionUpdateDrain(options.replayIdleMs ?? REPLAY_IDLE_MS, options.replayDrainTimeoutMs ?? REPLAY_DRAIN_TIMEOUT_MS);
 		} finally {
@@ -2743,7 +3048,8 @@ var AcpClient = class {
 		const response = await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.resume, {
 			sessionId,
 			cwd: sessionCwd,
-			mcpServers: this.options.mcpServers ?? []
+			mcpServers: this.options.mcpServers ?? [],
+			_meta: this.sessionMeta()
 		}), authority);
 		this.loadedSessionId = sessionId;
 		const result = toReconnectedSessionResult(response);
@@ -2862,11 +3168,11 @@ var AcpClient = class {
 		assertControlAuthority(authority);
 		const resolvedValue = models?.configId === configId ? this.resolveSessionModelId(value, models) : value;
 		const connection = this.getConnection();
-		return await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.setConfigOption, {
+		return normalizeConfigOptionAcknowledgement(await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.setConfigOption, {
 			sessionId,
 			configId,
 			value: resolvedValue
-		}), authority, (error) => maybeWrapSessionControlError("session/set_config_option", error, `for "${configId}"="${value}"`));
+		}), authority, (error) => maybeWrapSessionControlError("session/set_config_option", error, `for "${configId}"="${value}"`)));
 	}
 	async setSessionModel(sessionId, modelId, models, authority) {
 		assertControlAuthority(authority);
@@ -2888,11 +3194,11 @@ var AcpClient = class {
 	}
 	async setSessionModelThroughConfig(sessionId, modelId, configId, authority) {
 		const connection = this.getConnection();
-		return await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.setConfigOption, {
+		return normalizeConfigOptionAcknowledgement(await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.setConfigOption, {
 			sessionId,
 			configId,
 			value: modelId
-		}), authority, (error) => this.throwSessionModelError("session/set_config_option", modelId, error));
+		}), authority, (error) => this.throwSessionModelError("session/set_config_option", modelId, error)));
 	}
 	async setSessionModelThroughLegacyMethod(sessionId, modelId, authority) {
 		const connection = this.getConnection();
@@ -3659,6 +3965,7 @@ function removeModelConfigOptions(state) {
 	state.config_options = state.config_options.filter((option) => option.category !== "model" && option.id !== "model");
 }
 function applyConfigOptionsModelState(state, configOptions) {
+	if (!Array.isArray(configOptions)) return;
 	const previousConfigModels = modelStateFromConfigOptions(state.config_options);
 	const preservesLegacyControl = state.model_control === "legacy_set_model" || state.model_control === void 0 && previousConfigModels === void 0 && legacyModelState(state) !== void 0;
 	state.config_options = structuredClone(configOptions);
@@ -3668,14 +3975,9 @@ function applyConfigOptionsModelState(state, configOptions) {
 	else clearAdvertisedModelState(state);
 }
 //#endregion
-//#region src/session/conversation-model.ts
-const MAX_RUNTIME_MESSAGES = 200;
-const MAX_RUNTIME_AGENT_TEXT_CHARS = 8e3;
-const MAX_RUNTIME_THINKING_CHARS = 4e3;
-const MAX_RUNTIME_TOOL_IO_CHARS = 4e3;
-const MAX_RUNTIME_REQUEST_TOKEN_USAGE = 100;
-function isoNow() {
-	return (/* @__PURE__ */ new Date()).toISOString();
+//#region src/session/conversation-reducer.ts
+function resolveUserMessageId(value) {
+	return typeof value === "string" ? value : value();
 }
 function deepClone(value) {
 	try {
@@ -3731,6 +4033,7 @@ function contentToUserContent(content) {
 	if (content.type === "resource") return resourceToUserContent(content);
 	if (content.type === "image") return { Image: {
 		source: content.data,
+		mime_type: content.mimeType,
 		size: null
 	} };
 	if (content.type === "audio") return { Audio: {
@@ -3745,9 +4048,6 @@ function resourceToUserContent(content) {
 		content: content.resource.uri
 	} };
 }
-function nextUserMessageId() {
-	return randomUUID();
-}
 function isUserMessage(message) {
 	return typeof message === "object" && message !== null && hasOwn(message, "User");
 }
@@ -3779,7 +4079,7 @@ function ensureAgentMessage(conversation) {
 function appendAgentText(agent, text) {
 	const last = agent.content.at(-1);
 	if (last && isAgentTextContent(last)) {
-		last.Text = trimRuntimeText(`${last.Text}${text}`, MAX_RUNTIME_AGENT_TEXT_CHARS);
+		last.Text = `${last.Text}${text}`;
 		return;
 	}
 	const next = { Text: text };
@@ -3788,7 +4088,7 @@ function appendAgentText(agent, text) {
 function appendAgentThinking(agent, text) {
 	const last = agent.content.at(-1);
 	if (last && isAgentThinkingContent(last)) {
-		last.Thinking.text = trimRuntimeText(`${last.Thinking.text}${text}`, MAX_RUNTIME_THINKING_CHARS);
+		last.Thinking.text = `${last.Thinking.text}${text}`;
 		return;
 	}
 	const next = { Thinking: {
@@ -3797,10 +4097,6 @@ function appendAgentThinking(agent, text) {
 	} };
 	agent.content.push(next);
 }
-function trimRuntimeText(value, maxChars) {
-	if (value.length <= maxChars) return value;
-	return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
-}
 function statusIndicatesComplete(status) {
 	if (typeof status !== "string") return false;
 	const normalized = status.toLowerCase();
@@ -3812,18 +4108,18 @@ function statusIndicatesError(status) {
 	return normalized.includes("fail") || normalized.includes("error");
 }
 function toToolResultContent(value) {
-	if (typeof value === "string") return { Text: trimRuntimeText(value, MAX_RUNTIME_TOOL_IO_CHARS) };
+	if (typeof value === "string") return { Text: value };
 	if (value != null) try {
-		return { Text: trimRuntimeText(JSON.stringify(value), MAX_RUNTIME_TOOL_IO_CHARS) };
+		return { Text: JSON.stringify(value) ?? "[Unserializable value]" };
 	} catch {
 		return { Text: "[Unserializable value]" };
 	}
 	return { Text: "" };
 }
 function toRawInput(value) {
-	if (typeof value === "string") return trimRuntimeText(value, MAX_RUNTIME_TOOL_IO_CHARS);
+	if (typeof value === "string") return value;
 	try {
-		return trimRuntimeText(JSON.stringify(value ?? {}), MAX_RUNTIME_TOOL_IO_CHARS);
+		return JSON.stringify(value ?? {}) ?? "[Unserializable input]";
 	} catch {
 		return value == null ? "" : "[Unserializable input]";
 	}
@@ -3868,11 +4164,13 @@ function existingToolResultValues(existing) {
 	};
 }
 function applyToolCallUpdate(agent, update) {
+	const contentCount = agent.content.length;
 	const tool = ensureToolUseContent(agent, update.toolCallId);
 	applyToolIdentityUpdate(tool, update);
 	applyToolInputUpdate(tool, update);
 	applyToolStatusUpdate(tool, update);
 	applyToolResultUpdate(agent, tool, update);
+	return agent.content.length !== contentCount || hasOwn(update, "rawInput") || hasToolResultPatch(update);
 }
 function applyToolIdentityUpdate(tool, update) {
 	if (hasOwn(update, "title")) tool.name = normalizeAgentName(update.title) ?? tool.name ?? "tool_call";
@@ -3975,7 +4273,7 @@ function lastUserMessageId(conversation) {
 		if (message && isUserMessage(message)) return message.User.id;
 	}
 }
-function createSessionConversation(timestamp = isoNow()) {
+function createConversation(timestamp) {
 	return {
 		title: null,
 		messages: [],
@@ -3985,8 +4283,7 @@ function createSessionConversation(timestamp = isoNow()) {
 		request_token_usage: {}
 	};
 }
-function cloneSessionConversation(conversation) {
-	if (!conversation) return createSessionConversation();
+function cloneConversation(conversation) {
 	return {
 		title: conversation.title,
 		messages: deepClone(conversation.messages ?? []),
@@ -4027,57 +4324,47 @@ function cloneSessionOptions(options) {
 function cloneSystemPromptOption(option) {
 	return typeof option === "string" ? option : { append: option.append };
 }
-function recordPromptSubmission(conversation, prompt, timestamp = isoNow(), messageId) {
+function reducePromptSubmission(conversation, prompt, timestamp, messageId) {
 	const userContent = (typeof prompt === "string" ? textPrompt(prompt) : prompt).map((content) => contentToUserContent(content)).filter((content) => content !== void 0);
-	if (userContent.length === 0) return;
-	const promptMessageId = messageId ?? nextUserMessageId();
+	if (userContent.length === 0) return { messageIndex: void 0 };
 	conversation.messages.push({ User: {
-		id: promptMessageId,
-		content: userContent.map((content) => {
-			if ("Text" in content) return { Text: trimRuntimeText(content.Text, MAX_RUNTIME_AGENT_TEXT_CHARS) };
-			return content;
-		})
+		id: resolveUserMessageId(messageId),
+		content: userContent
 	} });
 	updateConversationTimestamp(conversation, timestamp);
-	trimConversationForRuntime(conversation);
-	return promptMessageId;
+	return { messageIndex: conversation.messages.length - 1 };
 }
-function recordSessionUpdate(conversation, state, notification, timestamp = isoNow(), userMessageId) {
+function reduceSessionUpdate(conversation, state, notification, timestamp, userMessageId) {
 	const acpx = ensureAcpxState$1(state);
-	const update = notification.update;
-	applySessionUpdate(conversation, acpx, update, userMessageId);
+	const messageIndex = applySessionUpdate(conversation, acpx, notification.update, userMessageId);
 	updateConversationTimestamp(conversation, timestamp);
-	trimConversationForRuntime(conversation);
-	return acpx;
+	return {
+		acpx,
+		messageIndex
+	};
 }
-function recordPromptResponseUsage(conversation, usage, promptMessageId, timestamp = isoNow()) {
+function reducePromptResponseUsage(conversation, usage, promptMessageId, timestamp) {
 	const tokenUsage = sourceToTokenUsage(usage);
 	if (!tokenUsage) return false;
 	applyTokenUsage(conversation, tokenUsage, promptMessageId);
 	updateConversationTimestamp(conversation, timestamp);
-	trimConversationForRuntime(conversation);
 	return true;
 }
 function applySessionUpdate(conversation, acpx, update, userMessageId) {
-	const handler = SESSION_UPDATE_HANDLERS[update.sessionUpdate];
-	handler?.(conversation, acpx, update, userMessageId);
+	return (Object.hasOwn(SESSION_UPDATE_HANDLERS, update.sessionUpdate) ? SESSION_UPDATE_HANDLERS[update.sessionUpdate] : void 0)?.(conversation, acpx, update, userMessageId);
 }
 const SESSION_UPDATE_HANDLERS = {
 	user_message_chunk: (conversation, _acpx, update, userMessageId) => {
-		if (update.sessionUpdate === "user_message_chunk") appendUserMessageChunk(conversation, update.content, userMessageId);
+		if (update.sessionUpdate === "user_message_chunk") return appendUserMessageChunk(conversation, update.content, userMessageId);
 	},
 	agent_message_chunk: (conversation, _acpx, update) => {
-		if (update.sessionUpdate === "agent_message_chunk") appendAgentMessageChunk(conversation, update.content, appendAgentText);
+		if (update.sessionUpdate === "agent_message_chunk") return appendAgentMessageChunk(conversation, update.content, appendAgentText);
 	},
 	agent_thought_chunk: (conversation, _acpx, update) => {
-		if (update.sessionUpdate === "agent_thought_chunk") appendAgentMessageChunk(conversation, update.content, appendAgentThinking);
-	},
-	tool_call: (conversation, _acpx, update) => {
-		if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") applyToolCallUpdate(ensureAgentMessage(conversation), update);
-	},
-	tool_call_update: (conversation, _acpx, update) => {
-		if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") applyToolCallUpdate(ensureAgentMessage(conversation), update);
+		if (update.sessionUpdate === "agent_thought_chunk") return appendAgentMessageChunk(conversation, update.content, appendAgentThinking);
 	},
+	tool_call: applyToolUpdate,
+	tool_call_update: applyToolUpdate,
 	usage_update: (conversation, _acpx, update) => {
 		if (update.sessionUpdate === "usage_update") applyUsageUpdate(conversation, update);
 	},
@@ -4094,17 +4381,24 @@ const SESSION_UPDATE_HANDLERS = {
 		if (update.sessionUpdate === "config_option_update") applyConfigOptionsModelState(acpx, deepClone(update.configOptions));
 	}
 };
+function applyToolUpdate(conversation, _acpx, update) {
+	if (update.sessionUpdate !== "tool_call" && update.sessionUpdate !== "tool_call_update") return;
+	return applyToolCallUpdate(ensureAgentMessage(conversation), update) ? conversation.messages.length - 1 : void 0;
+}
 function appendUserMessageChunk(conversation, content, messageId) {
 	const userContent = contentToUserContent(content);
 	if (!userContent) return;
 	conversation.messages.push({ User: {
-		id: messageId ?? nextUserMessageId(),
+		id: resolveUserMessageId(messageId),
 		content: [userContent]
 	} });
+	return conversation.messages.length - 1;
 }
 function appendAgentMessageChunk(conversation, content, append) {
 	const text = extractText(content);
-	if (text) append(ensureAgentMessage(conversation), text);
+	if (!text) return;
+	append(ensureAgentMessage(conversation), text);
+	return conversation.messages.length - 1;
 }
 function applyUsageUpdate(conversation, update) {
 	const usage = usageToTokenUsage(update);
@@ -4116,17 +4410,30 @@ function applyUsageUpdate(conversation, update) {
 function applyTokenUsage(conversation, usage, promptMessageId) {
 	conversation.cumulative_token_usage = usage;
 	const userId = promptMessageId ?? lastUserMessageId(conversation);
-	if (userId) conversation.request_token_usage[userId] = usage;
+	if (userId) Object.defineProperty(conversation.request_token_usage, userId, {
+		value: usage,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
 }
 function applySessionInfoUpdate(conversation, update) {
 	if (hasOwn(update, "title")) conversation.title = update.title ?? null;
 	if (hasOwn(update, "updatedAt")) conversation.updated_at = update.updatedAt ?? conversation.updated_at;
 }
-function recordClientOperation(conversation, state, _operation, timestamp = isoNow()) {
-	const acpx = ensureAcpxState$1(state);
-	updateConversationTimestamp(conversation, timestamp);
-	trimConversationForRuntime(conversation);
-	return acpx;
+//#endregion
+//#region src/session/conversation-retention.ts
+const MAX_RUNTIME_MESSAGES = 200;
+const MAX_RUNTIME_AGENT_TEXT_CHARS = 8e3;
+const MAX_RUNTIME_THINKING_CHARS = 4e3;
+const MAX_RUNTIME_TOOL_IO_CHARS = 4e3;
+const MAX_RUNTIME_REQUEST_TOKEN_USAGE = 100;
+function trimRuntimeText(value, maxChars) {
+	if (value.length <= maxChars) return value;
+	let end = Math.max(0, maxChars - 3);
+	const last = value.charCodeAt(end - 1);
+	if (last >= 55296 && last <= 56319) end -= 1;
+	return `${value.slice(0, end)}...`;
 }
 function trimConversationForRuntime(conversation) {
 	if (conversation.messages.length > MAX_RUNTIME_MESSAGES) conversation.messages = conversation.messages.slice(-200);
@@ -4161,6 +4468,39 @@ function trimRuntimeToolResult(result) {
 	if (typeof result.output === "string") result.output = trimRuntimeText(result.output, MAX_RUNTIME_TOOL_IO_CHARS);
 }
 //#endregion
+//#region src/session/conversation-model.ts
+function isoNow() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createSessionConversation(timestamp = isoNow()) {
+	return createConversation(timestamp);
+}
+function cloneSessionConversation(conversation) {
+	return conversation ? cloneConversation(conversation) : createSessionConversation();
+}
+function recordPromptSubmission(conversation, prompt, timestamp = isoNow(), messageId) {
+	let promptMessageId = messageId;
+	if (reducePromptSubmission(conversation, prompt, timestamp, () => promptMessageId ??= randomUUID()).messageIndex === void 0) return;
+	trimConversationForRuntime(conversation);
+	return promptMessageId;
+}
+function recordSessionUpdate(conversation, state, notification, timestamp = isoNow(), userMessageId) {
+	const { acpx } = reduceSessionUpdate(conversation, state, notification, timestamp, userMessageId ?? randomUUID);
+	trimConversationForRuntime(conversation);
+	return acpx;
+}
+function recordPromptResponseUsage(conversation, usage, promptMessageId, timestamp = isoNow()) {
+	if (!reducePromptResponseUsage(conversation, usage, promptMessageId, timestamp)) return false;
+	trimConversationForRuntime(conversation);
+	return true;
+}
+function recordClientOperation(conversation, state, _operation, timestamp = isoNow()) {
+	const acpx = state ?? {};
+	conversation.updated_at = timestamp;
+	trimConversationForRuntime(conversation);
+	return acpx;
+}
+//#endregion
 //#region src/runtime/engine/lifecycle.ts
 function createInitialSessionRecord(params) {
 	const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4283,19 +4623,27 @@ function storedEnvRecord(value) {
 	const result = {};
 	for (const [key, raw] of entries) {
 		if (typeof raw !== "string") continue;
-		result[key] = raw;
+		Object.defineProperty(result, key, {
+			value: raw,
+			writable: true,
+			enumerable: true,
+			configurable: true
+		});
 	}
 	return Object.keys(result).length > 0 ? result : void 0;
 }
 function normalizeSystemPromptOption(value) {
-	const prompt = nonEmptyString(value);
+	const prompt = nonEmptyPromptText(value);
 	if (prompt !== void 0) return prompt;
 	const append = appendedSystemPrompt(value);
 	return append === void 0 ? void 0 : { append };
 }
 function appendedSystemPrompt(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return;
-	return nonEmptyString(value.append);
+	return nonEmptyPromptText(value.append);
+}
+function nonEmptyPromptText(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
 }
 function storedAllowedTools(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string") ? [...value] : void 0;
@@ -4346,316 +4694,108 @@ function clearDesiredConfigOption(state, configId) {
 function getDesiredModelId(state) {
 	return normalizeModelId(state?.session_options?.model);
 }
-function setCurrentModelId(record, modelId) {
-	const acpx = ensureAcpxState(record.acpx);
-	const normalized = normalizeModelId(modelId);
-	if (normalized) acpx.current_model_id = normalized;
-	else delete acpx.current_model_id;
-	record.acpx = acpx;
-}
 function syncAdvertisedModelState(record, models) {
 	if (!models) return;
-	const acpx = ensureAcpxState(record.acpx);
-	applyAdvertisedModelState(acpx, models);
-	record.acpx = acpx;
-}
-//#endregion
-//#region src/session/model-application.ts
-function currentModelIdFromSetModelResponse(response, fallbackModelId) {
-	return modelStateFromConfigOptions(response?.configOptions)?.currentModelId ?? fallbackModelId;
-}
-async function applyRequestedModelIfAdvertised(params) {
-	const requestedModel = typeof params.requestedModel === "string" ? params.requestedModel.trim() : "";
-	if (!requestedModel) return { applied: false };
-	const warning = assertRequestedModelSupported({
-		requestedModel,
-		models: params.models,
-		agentCommand: params.agentCommand,
-		context: "apply"
-	});
-	if (warning) params.onWarning?.(warning);
-	if (!params.models) return { applied: false };
-	if (params.models.currentModelId === requestedModel) return { applied: true };
-	return {
-		applied: true,
-		response: await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, params.models, params.authority), params.timeoutMs)
-	};
-}
-//#endregion
-//#region src/session/config-options.ts
-function applyConfigOptionsToState(state, configOptions) {
-	const acpxState = cloneSessionAcpxState(state) ?? {};
-	applyConfigOptionsModelState(acpxState, configOptions);
-	return acpxState;
-}
-function applyConfigOptionsToRecord(record, result) {
-	const configOptions = result?.configOptions;
-	if (!configOptions) return;
-	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
-}
-function applyInitialModelSelection(record, originalModels, requestedModel, modelApplication) {
-	applyConfigOptionsToRecord(record, modelApplication.response);
-	syncAdvertisedModelState(record, modelApplication.response ? modelStateFromConfigOptions(modelApplication.response.configOptions) : originalModels);
-	if (modelApplication.applied) setCurrentModelId(record, currentModelIdFromSetModelResponse(modelApplication.response, requestedModel));
-}
-function applyAcceptedConfigOptions(state, response) {
-	const next = cloneSessionAcpxState(state) ?? {};
-	if (!response) return next;
-	applyConfigOptionsModelState(next, response.configOptions);
-	if (!next.desired_config_options) return next;
-	const desiredEntries = [];
-	for (const option of response.configOptions) if (typeof option.currentValue === "string" && Object.hasOwn(next.desired_config_options, option.id)) desiredEntries.push([option.id, option.currentValue]);
-	if (desiredEntries.length > 0) next.desired_config_options = Object.fromEntries(desiredEntries);
-	else delete next.desired_config_options;
-	return next;
-}
-function applyModelSelection(state, modelId, response) {
-	const modelConfigId = advertisedModelState(state)?.configId;
-	const next = applyAcceptedConfigOptions(state, response);
-	next.session_options = {
-		...next.session_options,
-		model: modelId
-	};
-	next.current_model_id = currentModelIdFromSetModelResponse(response, modelId);
-	clearDesiredConfigOption(next, modelConfigId ?? advertisedModelState(next)?.configId);
-	return next;
-}
-function applyConfigOptionSelection(state, configId, value, response, modelConfigId = advertisedModelState(state)?.configId) {
-	if (configId === modelConfigId || configId === modelStateFromConfigOptions(response.configOptions)?.configId) return applyModelSelection(state, value, response);
-	const next = cloneSessionAcpxState(state) ?? {};
-	next.desired_config_options = {
-		...next.desired_config_options,
-		[configId]: value
-	};
-	return applyAcceptedConfigOptions(next, response);
-}
-//#endregion
-//#region src/session/turn-ownership.ts
-const LOCK_RETRY_MS = 15;
-const INCOMPLETE_RESERVATION_GRACE_MS = 15e3;
-let lastCreatedAt = 0;
-const localTurns = /* @__PURE__ */ new Map();
-async function readLock(filePath) {
-	try {
-		const stat = await fs$1.lstat(filePath, { bigint: true });
-		if (!stat.isFile()) throw new Error(`Session turn lock is not a regular file: ${filePath}`);
-		return {
-			stat,
-			payload: await fs$1.readFile(filePath, "utf8")
-		};
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		throw error;
-	}
-}
-function parseLock(payload) {
-	try {
-		return JSON.parse(payload);
-	} catch {
-		return;
-	}
-}
-async function tryAcquireGuard(filePath, owner, signal) {
-	try {
-		return await acquireFileLock(filePath, {
-			managerKey: "acpx.session-turn",
-			lockPath: `${filePath}.guard`,
-			staleMs: Infinity,
-			timeoutMs: LOCK_RETRY_MS,
-			retry: {
-				retries: 8,
-				minTimeout: 1,
-				maxTimeout: 2,
-				factor: 1,
-				randomize: false
-			},
-			staleRecovery: "remove-if-unchanged",
-			payload: () => owner.payload,
-			shouldReclaim: ({ payload }) => owner.hasExited(payload, false, signal),
-			shouldRemoveStaleLock: ({ payload }) => owner.hasExited(payload, true, signal)
-		});
-	} catch (error) {
-		if (error.code === "file_lock_timeout") return;
-		throw error;
-	}
-}
-async function removeObservedLock(filePath, observed) {
-	const current = await readLock(filePath);
-	if (!current) return true;
-	if (current.payload !== observed.payload || current.stat.mtimeNs !== observed.stat.mtimeNs || current.stat.size !== observed.stat.size) return false;
-	await fs$1.unlink(filePath).catch((error) => {
-		if (error.code !== "ENOENT") throw error;
-	});
-	return true;
-}
-async function recoverAbandonedLock(filePath, owner, signal) {
-	const observed = await readLock(filePath);
-	if (!observed) return true;
-	const payload = parseLock(observed.payload);
-	const pid = lockOwnerPid(payload);
-	if (pid && (!await owner.hasExited(payload, false, signal) || !await owner.hasExited(payload, true, signal))) return false;
-	if (!pid && Date.now() - Number(observed.stat.mtimeMs) <= INCOMPLETE_RESERVATION_GRACE_MS) return false;
-	if (await removeObservedLock(filePath, observed)) {
-		incrementPerfCounter("session.events.stale_lock_recovered");
-		return true;
-	}
-	return false;
-}
-async function publishLock(filePath, payload, signal) {
-	await withTempFile({
-		rootDir: path.dirname(filePath),
-		prefix: "session-turn",
-		fileName: "lock"
-	}, async (temporaryPath) => {
-		await fs$1.writeFile(temporaryPath, payload, {
-			encoding: "utf8",
-			flag: "wx",
-			mode: 384
-		});
-		signal?.throwIfAborted();
-		try {
-			await fs$1.link(temporaryPath, filePath);
-		} catch (error) {
-			if (!isHardlinkFallbackError(error)) throw error;
-			await fs$1.writeFile(filePath, payload, {
-				encoding: "utf8",
-				flag: "wx",
-				mode: 384
-			});
-		}
-	});
+	const acpx = ensureAcpxState(record.acpx);
+	applyAdvertisedModelState(acpx, models);
+	record.acpx = acpx;
 }
-async function removePublishedLock(filePath, payload) {
-	const current = await readLock(filePath);
-	if (current?.payload === payload) await removeObservedLock(filePath, current);
+//#endregion
+//#region src/session/model-application.ts
+function currentModelIdFromSetModelResponse(response, fallbackModelId) {
+	return modelStateFromConfigOptions(response?.configOptions)?.currentModelId ?? fallbackModelId;
 }
-async function rejectAcquisition(filePath, receipt, error) {
-	const failures = [error];
-	await disposeTurn(filePath, receipt).catch((cleanupError) => {
-		failures.push(...cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError]);
+async function applyRequestedModelIfAdvertised(params) {
+	const requestedModel = typeof params.requestedModel === "string" ? params.requestedModel.trim() : "";
+	if (!requestedModel) return { applied: false };
+	const warning = assertRequestedModelSupported({
+		requestedModel,
+		models: params.models,
+		agentCommand: params.agentCommand,
+		context: "apply"
 	});
-	if (failures.length > 1) throw new AggregateError(failures, "Session turn acquisition and cleanup failed");
-	throw error;
-}
-async function releaseTurnGuard(receipt) {
-	await receipt.guard?.release();
-	receipt.guard = void 0;
+	if (warning) params.onWarning?.(warning);
+	if (!params.models) return { applied: false };
+	const resolvedModelId = resolveRequestedModelId({
+		...params,
+		requestedModel
+	});
+	if (params.models.currentModelId === resolvedModelId) return {
+		applied: true,
+		modelId: requestedModel,
+		resolvedModelId
+	};
+	return {
+		applied: true,
+		modelId: requestedModel,
+		resolvedModelId,
+		response: await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, params.models, params.authority), params.timeoutMs)
+	};
 }
-async function removeTurnMarker(filePath, receipt) {
-	if (!receipt.removeMarker) return true;
-	if (receipt.guard && !await receipt.guard.verifyStillHeld()) await releaseTurnGuard(receipt);
-	receipt.guard ??= await tryAcquireGuard(filePath, receipt.owner);
-	if (!receipt.guard) return false;
-	await receipt.removeMarker();
-	receipt.removeMarker = void 0;
-	return true;
+//#endregion
+//#region src/session/config-options.ts
+function applyConfigOptionsToState(state, configOptions) {
+	const acpxState = cloneSessionAcpxState(state) ?? {};
+	applyConfigOptionsModelState(acpxState, configOptions);
+	return acpxState;
 }
-async function settleTurn(filePath, receipt) {
-	if (receipt.settled) return true;
-	const pending = receipt.pending ??= (async () => {
-		receipt.failed = false;
-		const failures = [];
-		try {
-			if (!await removeTurnMarker(filePath, receipt)) return false;
-		} catch (error) {
-			failures.push(error);
-		}
-		if (failures.length === 0 || !receipt.admitted) try {
-			await releaseTurnGuard(receipt);
-		} catch (error) {
-			failures.push(error);
-		}
-		if (failures.length > 1) throw new AggregateError(failures, "Session turn cleanup failed");
-		if (failures.length === 1) throw failures[0];
-		receipt.settled = true;
-		localTurns.delete(filePath);
-		return true;
-	})();
-	try {
-		return await pending;
-	} finally {
-		if (receipt.pending === pending) {
-			receipt.pending = void 0;
-			receipt.failed = !receipt.settled;
-		}
-	}
+function applyConfigOptionsToRecord(record, result) {
+	const configOptions = result?.configOptions;
+	if (!Array.isArray(configOptions)) return;
+	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
 }
-async function disposeTurn(filePath, receipt) {
-	if (!await settleTurn(filePath, receipt)) throw new Error(`Session turn cleanup is waiting for its guard: ${filePath}`);
+function applyInitialModelSelection(record, originalModels, modelApplication) {
+	applyConfigOptionsToRecord(record, modelApplication.response);
+	const configOptions = modelApplication.response?.configOptions;
+	syncAdvertisedModelState(record, Array.isArray(configOptions) ? modelStateFromConfigOptions(configOptions) : originalModels);
+	if (modelApplication.applied) record.acpx = applyModelSelection(record.acpx, modelApplication.modelId, modelApplication.response, modelApplication.resolvedModelId);
 }
-async function tryPublishLock(filePath, payload, owner, signal) {
-	for (;;) try {
-		await publishLock(filePath, payload, signal);
-		return true;
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		if (!await recoverAbandonedLock(filePath, owner, signal)) return false;
+function applyAcceptedConfigOptions(state, response, selection) {
+	const next = cloneSessionAcpxState(state) ?? {};
+	if (!Array.isArray(response?.configOptions)) {
+		const option = next.config_options?.find((entry) => entry.id === selection.configId);
+		if (option) option.currentValue = selection.value;
+		return next;
 	}
+	applyConfigOptionsModelState(next, response.configOptions);
+	reconcileDesiredConfigOptions(next, response.configOptions);
+	return next;
 }
-async function tryAcquireTurnCleanup(filePath, payload, owner, signal) {
-	const previous = localTurns.get(filePath);
-	if (previous) {
-		if (previous.failed) await settleTurn(filePath, previous);
-		return;
-	}
-	const receipt = {
-		owner,
-		removeMarker: async () => await removePublishedLock(filePath, payload),
-		admitted: false,
-		failed: false,
-		settled: false
+function reconcileDesiredConfigOptions(state, configOptions) {
+	if (!state.desired_config_options) return;
+	const desiredEntries = [];
+	for (const option of configOptions) if (typeof option.currentValue === "string" && Object.hasOwn(state.desired_config_options, option.id)) desiredEntries.push([option.id, option.currentValue]);
+	if (desiredEntries.length > 0) state.desired_config_options = Object.fromEntries(desiredEntries);
+	else delete state.desired_config_options;
+}
+function applyModelSelection(state, modelId, response, resolvedModelId = modelId) {
+	const modelConfigId = advertisedModelState(state)?.configId;
+	const next = applyAcceptedConfigOptions(state, response, {
+		configId: modelConfigId,
+		value: resolvedModelId
+	});
+	next.session_options = {
+		...next.session_options,
+		model: modelId
 	};
-	localTurns.set(filePath, receipt);
-	try {
-		receipt.guard = await tryAcquireGuard(filePath, owner, signal);
-	} catch (error) {
-		localTurns.delete(filePath);
-		throw error;
-	}
-	if (!receipt.guard) {
-		localTurns.delete(filePath);
-		return;
-	}
-	return receipt;
+	next.current_model_id = currentModelIdFromSetModelResponse(response, resolvedModelId);
+	clearDesiredConfigOption(next, modelConfigId ?? advertisedModelState(next)?.configId);
+	return next;
 }
-async function tryAcquireTurn(filePath, payload, owner, signal) {
-	const receipt = await tryAcquireTurnCleanup(filePath, payload, owner, signal);
-	if (!receipt) return;
-	try {
-		signal?.throwIfAborted();
-		if (!await tryPublishLock(filePath, payload, owner, signal)) {
-			await disposeTurn(filePath, receipt);
-			return;
-		}
-		const observed = await readLock(filePath);
-		if (observed?.payload !== payload) throw new Error(`Session turn ownership changed before admission: ${filePath}`);
-		signal?.throwIfAborted();
-		receipt.admitted = true;
-		receipt.removeMarker = async () => await removeObservedLock(filePath, observed);
-		return { [Symbol.asyncDispose]: async () => await disposeTurn(filePath, receipt) };
-	} catch (error) {
-		return await rejectAcquisition(filePath, receipt, error);
-	}
+function isModelConfigSelection(configId, response, modelConfigId) {
+	return configId === modelConfigId || configId === modelStateFromConfigOptions(response?.configOptions)?.configId;
 }
-async function acquireSessionTurn(recordId, signal) {
-	const requestedPath = sessionEventLockPath(recordId);
-	await fs$1.mkdir(path.dirname(requestedPath), {
-		recursive: true,
-		mode: 448
+function applyConfigOptionSelection(state, configId, value, response, modelConfigId = advertisedModelState(state)?.configId, resolvedValue = value) {
+	if (isModelConfigSelection(configId, response, modelConfigId)) return applyModelSelection(state, value, response, resolvedValue);
+	const next = cloneSessionAcpxState(state) ?? {};
+	next.desired_config_options = {
+		...next.desired_config_options,
+		[configId]: value
+	};
+	return applyAcceptedConfigOptions(next, response, {
+		configId,
+		value
 	});
-	const filePath = path.join(await fs$1.realpath(path.dirname(requestedPath)), path.basename(requestedPath));
-	const owner = await createLockOwner({ signal });
-	lastCreatedAt = Math.max(Date.now(), lastCreatedAt + 1);
-	const payload = `${JSON.stringify({
-		...owner.payload,
-		created_at: new Date(lastCreatedAt).toISOString()
-	}, null, 2)}\n`;
-	for (;;) {
-		signal?.throwIfAborted();
-		const turn = await tryAcquireTurn(filePath, payload, owner, signal);
-		if (turn) return turn;
-		await setTimeout$1(LOCK_RETRY_MS, void 0, { signal });
-	}
 }
 //#endregion
 //#region src/session/execution/direct-lifetime.ts
@@ -4754,13 +4894,15 @@ async function replayDesiredModel(params) {
 			context: "replay"
 		}), params.suppressWarnings);
 		if (!params.models) return { replayed: false };
+		const resolvedModelId = resolveRequestedModelId({
+			requestedModel: params.desiredModelId,
+			models: params.models,
+			agentCommand: params.record.agentCommand
+		});
 		const response = await withTimeout(params.client.setSessionModel(params.sessionId, params.desiredModelId, params.models, params.replay.authority), params.timeoutMs);
 		params.replay.acknowledged = true;
-		params.record.acpx = applyModelSelection(params.record.acpx, params.desiredModelId, response);
-		const models = response ? modelStateFromConfigOptions(response.configOptions) : {
-			...params.models,
-			currentModelId: params.desiredModelId
-		};
+		params.record.acpx = applyModelSelection(params.record.acpx, params.desiredModelId, response, resolvedModelId);
+		const models = advertisedModelState(params.record.acpx);
 		if (params.verbose) process.stderr.write(`[acpx] replayed desired model ${params.desiredModelId} on ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
 		return {
 			replayed: true,
@@ -4785,13 +4927,20 @@ async function replayDesiredConfigOptions(params) {
 	for (const [configId, value] of Object.entries(params.desiredConfigOptions)) {
 		if (configId === replacingKey || acceptedConfigOptions && !acceptsSavedConfigValue(acceptedConfigOptions.find((option) => option.id === configId), value)) continue;
 		try {
-			const response = await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value, advertisedModelState(params.record.acpx), params.replay.authority), params.timeoutMs);
+			const models = advertisedModelState(params.record.acpx);
+			const { modelConfigId, resolvedValue } = resolveRequestedConfigOption({
+				configId,
+				value,
+				models,
+				agentCommand: params.record.agentCommand
+			});
+			const response = await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value, models, params.replay.authority), params.timeoutMs);
 			params.replay.acknowledged = true;
-			params.record.acpx = applyConfigOptionSelection(params.record.acpx, configId, value, response);
-			acceptedConfigOptions = response.configOptions;
+			params.record.acpx = applyConfigOptionSelection(params.record.acpx, configId, value, response, modelConfigId, resolvedValue);
+			acceptedConfigOptions = params.record.acpx.config_options;
 			result = {
 				replayed: true,
-				models: modelStateFromConfigOptions(response.configOptions)
+				models: advertisedModelState(params.record.acpx)
 			};
 			if (params.verbose) process.stderr.write(`[acpx] replayed desired config option ${configId} on ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
 		} catch (error) {
@@ -4823,7 +4972,7 @@ async function connectAndLoadSession(options) {
 	logReconnectAttempt(record, storedProcessAlive, Boolean(record.pid) && !storedProcessAlive, options.verbose);
 	const reusingLoadedSession = client.hasReusableSession(record.acpSessionId);
 	if (reusingLoadedSession) incrementPerfCounter("runtime.connect_and_load.reused_session");
-	else await withTimeout(client.start(options.authority), options.timeoutMs);
+	else await withTimeout(client.start(options.authority, { sessionOptions: mergeSessionOptions(options.sessionOptions, sessionOptionsFromRecord(record)) }), options.timeoutMs);
 	assertControlAuthority(options.authority);
 	options.onClientAvailable?.(options.activeController);
 	applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
@@ -5240,8 +5389,13 @@ async function runSessionSetModelDirect(options) {
 		replacingConfigOption: { key: "model" }
 	}, async ({ client, sessionId, record }) => {
 		const models = advertisedModelState(record.acpx);
+		const resolvedModelId = resolveRequestedModelId({
+			requestedModel: options.modelId,
+			models,
+			agentCommand: record.agentCommand
+		});
 		const response = await withTimeout(client.setSessionModel(sessionId, options.modelId, models), options.timeoutMs);
-		record.acpx = applyModelSelection(record.acpx, options.modelId, response);
+		record.acpx = applyModelSelection(record.acpx, options.modelId, response, resolvedModelId);
 		return response;
 	}));
 	return {
@@ -5255,8 +5409,14 @@ async function runSessionSetConfigOptionDirect(options) {
 		replacingConfigOption: { key: options.configId }
 	}, async ({ client, sessionId, record }) => {
 		const models = advertisedModelState(record.acpx);
+		const { modelConfigId, resolvedValue } = resolveRequestedConfigOption({
+			configId: options.configId,
+			value: options.value,
+			models,
+			agentCommand: record.agentCommand
+		});
 		const response = await withTimeout(client.setSessionConfigOption(sessionId, options.configId, options.value, models), options.timeoutMs);
-		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, response, models?.configId);
+		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, response, modelConfigId, resolvedValue);
 		return response;
 	}));
 	return {
@@ -5402,7 +5562,11 @@ async function setSessionModelOnOwner(options) {
 	if (!submittedToOwner) return;
 	const record = await resolveSessionRecord(options.sessionId);
 	if (!submittedToOwner.persistsControlState) {
-		record.acpx = applyModelSelection(record.acpx, options.modelId, submittedToOwner.value.response);
+		record.acpx = applyModelSelection(record.acpx, options.modelId, submittedToOwner.value.response, resolveRequestedModelId({
+			requestedModel: options.modelId,
+			models: advertisedModelState(record.acpx),
+			agentCommand: record.agentCommand
+		}));
 		await writeSessionRecord(record);
 	}
 	return {
@@ -5433,7 +5597,14 @@ async function setSessionConfigOptionOnOwner(options) {
 	if (!ownerResponse) return;
 	const record = await resolveSessionRecord(options.sessionId);
 	if (!ownerResponse.persistsControlState) {
-		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, ownerResponse.value);
+		const models = advertisedModelState(record.acpx);
+		const { modelConfigId, resolvedValue } = resolveRequestedConfigOption({
+			configId: options.configId,
+			value: options.value,
+			models,
+			agentCommand: record.agentCommand
+		});
+		record.acpx = applyConfigOptionSelection(record.acpx, options.configId, options.value, ownerResponse.value, modelConfigId, resolvedValue);
 		await writeSessionRecord(record);
 	}
 	return {
@@ -5551,7 +5722,7 @@ async function closeSession(sessionId) {
 }
 //#endregion
 //#region src/session/execution/session-management.ts
-async function createSessionRecordWithClient(client, options) {
+async function createSessionRecordWithClient(client, options, resumedRecordId) {
 	const cwd = absolutePath(options.cwd);
 	await withTimeout(client.start({ signal: options.signal }), options.timeoutMs);
 	assertControlAuthority({ signal: options.signal });
@@ -5561,7 +5732,7 @@ async function createSessionRecordWithClient(client, options) {
 	const lifecycle = client.getAgentLifecycleSnapshot();
 	const record = {
 		...createInitialSessionRecord({
-			recordId: sessionId,
+			recordId: resumedRecordId ?? randomUUID(),
 			sessionId,
 			agentSessionId,
 			agentCommand: options.agentCommand,
@@ -5577,7 +5748,7 @@ async function createSessionRecordWithClient(client, options) {
 	};
 	persistSessionOptions(record, options.sessionOptions);
 	applyConfigOptionsToRecord(record, createdState.sessionResult);
-	applyInitialModelSelection(record, createdState.sessionResult.models, options.sessionOptions?.model, createdState.modelApplication);
+	applyInitialModelSelection(record, createdState.sessionResult.models, createdState.modelApplication);
 	await writeSessionRecord(record);
 	assertControlAuthority({ signal: options.signal });
 	return record;
@@ -5632,6 +5803,20 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 }
 async function createSessionWithClient(options) {
 	assertControlAuthority({ signal: options.signal });
+	let resumedRecordId;
+	if (options.resumeSessionId) {
+		const resumedRecord = await readSessionRecord(options.resumeSessionId);
+		assertControlAuthority({ signal: options.signal });
+		if (resumedRecord && resumedRecord.agentCommand === options.agentCommand) {
+			resumedRecordId = resumedRecord.acpxRecordId;
+			if (!resumedRecord.closed) await closeSession(resumedRecord.acpxRecordId);
+			options = {
+				...options,
+				resumeSessionId: resumedRecord.acpSessionId
+			};
+			assertControlAuthority({ signal: options.signal });
+		}
+	}
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		agentArgv: options.agentArgv,
@@ -5651,7 +5836,7 @@ async function createSessionWithClient(options) {
 	try {
 		const create = async () => {
 			assertControlAuthority({ signal: options.signal });
-			const record = await createSessionRecordWithClient(client, options);
+			const record = await createSessionRecordWithClient(client, options, resumedRecordId);
 			assertControlAuthority({ signal: options.signal });
 			return record;
 		};
@@ -5719,11 +5904,11 @@ async function listAgentSessions(options) {
 }
 async function ensureSession(options) {
 	const cwd = absolutePath(options.cwd);
-	const ownership = await acquireSessionTurn(`ensure:${createHash("sha256").update(JSON.stringify([
-		options.agentCommand,
+	const ownership = await acquireSessionScope({
+		agentCommand: options.agentCommand,
 		cwd,
-		normalizeName(options.name)
-	])).digest("hex")}`, options.signal);
+		name: normalizeName(options.name)
+	}, options.signal);
 	try {
 		return await ensureSessionWithOwnership(options, cwd);
 	} finally {
@@ -6133,14 +6318,25 @@ function createOwnedSessionControls(options) {
 		},
 		setSessionModel: async (modelId, deadline) => {
 			const models = advertisedModelState(options.record.acpx);
+			const resolvedModelId = resolveRequestedModelId({
+				requestedModel: modelId,
+				models,
+				agentCommand: options.record.agentCommand
+			});
 			return await acceptControl(options, (authority) => options.client.setSessionModel(options.sessionId(), modelId, models, authority), (response) => {
-				options.record.acpx = applyModelSelection(options.record.acpx, modelId, response);
+				options.record.acpx = applyModelSelection(options.record.acpx, modelId, response, resolvedModelId);
 			}, deadline);
 		},
 		setSessionConfigOption: async (configId, value, deadline) => {
 			const models = advertisedModelState(options.record.acpx);
+			const { modelConfigId, resolvedValue } = resolveRequestedConfigOption({
+				configId,
+				value,
+				models,
+				agentCommand: options.record.agentCommand
+			});
 			return await acceptControl(options, (authority) => options.client.setSessionConfigOption(options.sessionId(), configId, value, models, authority), (response) => {
-				options.record.acpx = applyConfigOptionSelection(options.record.acpx, configId, value, response, models?.configId);
+				options.record.acpx = applyConfigOptionSelection(options.record.acpx, configId, value, response, modelConfigId, resolvedValue);
 			}, deadline);
 		}
 	};
@@ -6503,7 +6699,12 @@ var LiveSessionCheckpoint = class {
 	async flushDirty() {
 		while (this.dirty) {
 			this.dirty = false;
-			await this.save();
+			try {
+				await this.save();
+			} catch (error) {
+				this.dirty = true;
+				throw error;
+			}
 		}
 	}
 };
@@ -6557,8 +6758,8 @@ var QueueTaskOutputFormatter = class {
 	flush() {}
 };
 function markOutputAlreadyEmitted(error, outputAlreadyEmitted) {
-	if (!outputAlreadyEmitted || !error || typeof error !== "object") return;
-	error.outputAlreadyEmitted = true;
+	if (!error || typeof error !== "object") return;
+	error.outputAlreadyEmitted = outputAlreadyEmitted;
 }
 async function runWithOptionalInterrupt(options) {
 	if (options.handleProcessInterrupts === false) return await options.run();
@@ -6601,11 +6802,17 @@ var AcpErrorTracker = class {
 		return this.latestInbound ?? this.outbound.findLast((acp) => outboundAcpErrorMatches(error, acp));
 	}
 };
-function toPromptResult(stopReason, sessionId, client, meta) {
+function toPromptResult(stopReason, sessionId, client, before, meta) {
+	const after = client.getPermissionStats();
 	return {
 		stopReason,
 		sessionId,
-		permissionStats: client.getPermissionStats(),
+		permissionStats: {
+			requested: after.requested - before.requested,
+			approved: after.approved - before.approved,
+			denied: after.denied - before.denied,
+			cancelled: after.cancelled - before.cancelled
+		},
 		...meta === void 0 ? {} : { _meta: meta }
 	};
 }
@@ -6625,62 +6832,39 @@ async function applyPromptModelIfAdvertised(params) {
 		authority: { signal: params.signal },
 		onWarning: params.suppressWarnings ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 	});
-	if (result.applied) params.record.acpx = applyModelSelection(params.record.acpx, requestedModel, result.response);
+	if (result.applied) params.record.acpx = applyModelSelection(params.record.acpx, requestedModel, result.response, result.resolvedModelId);
 }
-function jsonRpcIdKey(value) {
+function jsonRpcIdKey(message) {
+	if (!("id" in message)) return;
+	const value = message.id;
 	if (typeof value === "string") return `s:${value}`;
 	if (typeof value === "number" && Number.isFinite(value)) return `n:${value}`;
 }
-function extractJsonRpcRequestInfo(message) {
-	const candidate = message;
-	if (typeof candidate.method !== "string") return;
-	const idKey = jsonRpcIdKey(candidate.id);
-	if (!idKey) return;
-	return {
-		idKey,
-		method: candidate.method
-	};
-}
-function extractJsonRpcResponseInfo(message) {
-	const candidate = message;
-	const idKey = jsonRpcIdKey(candidate.id);
-	if (!idKey) return;
-	const hasError = Object.hasOwn(candidate, "error");
-	const hasResult = Object.hasOwn(candidate, "result");
-	if (!hasError && !hasResult) return;
-	return {
-		idKey,
-		hasError
-	};
-}
 const SESSION_RECONNECT_METHODS = /* @__PURE__ */ new Set(["session/load", "session/resume"]);
-function filterRecoverableLoadFallbackOutput(messages) {
-	const requestMethodById = /* @__PURE__ */ new Map();
-	const failedLoadRequestIds = /* @__PURE__ */ new Set();
-	for (const message of messages) {
-		const request = extractJsonRpcRequestInfo(message);
-		if (request) {
-			requestMethodById.set(request.idKey, request.method);
-			continue;
-		}
-		const response = extractJsonRpcResponseInfo(message);
-		if (!response || !response.hasError) continue;
-		const requestMethod = requestMethodById.get(response.idKey);
-		if (requestMethod && SESSION_RECONNECT_METHODS.has(requestMethod)) failedLoadRequestIds.add(response.idKey);
-	}
-	if (failedLoadRequestIds.size === 0) return messages;
-	return messages.filter((message) => {
-		const request = extractJsonRpcRequestInfo(message);
-		if (request && SESSION_RECONNECT_METHODS.has(request.method) && failedLoadRequestIds.has(request.idKey)) return false;
-		const response = extractJsonRpcResponseInfo(message);
-		if (response && failedLoadRequestIds.has(response.idKey)) return false;
-		return true;
-	});
+function isReconnectRequest(direction, message) {
+	return direction === "outbound" && "method" in message && typeof message.method === "string" && SESSION_RECONNECT_METHODS.has(message.method);
+}
+function isInboundResponse(direction, message) {
+	return direction === "inbound" && ("result" in message || "error" in message);
 }
 function filterBufferedConnectOutput(messages, loadError) {
 	if (loadError == null) return messages;
-	const filteredMessages = new Set(filterRecoverableLoadFallbackOutput(messages.map(({ message }) => message)));
-	return messages.filter(({ message }) => filteredMessages.has(message));
+	const pending = /* @__PURE__ */ new Map();
+	const suppressed = /* @__PURE__ */ new Set();
+	for (const [index, { direction, message }] of messages.entries()) {
+		const id = jsonRpcIdKey(message);
+		if (!id) continue;
+		if (isReconnectRequest(direction, message)) pending.set(id, index);
+		else if (isInboundResponse(direction, message)) {
+			const requestIndex = pending.get(id);
+			if (requestIndex !== void 0 && "error" in message) {
+				suppressed.add(requestIndex);
+				suppressed.add(index);
+			}
+			pending.delete(id);
+		}
+	}
+	return messages.filter((_message, index) => !suppressed.has(index));
 }
 function emitPromptRetryNotice(params) {
 	if (params.suppressSdkConsoleErrors) return;
@@ -6744,7 +6928,7 @@ function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatt
 		suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
 		verbose: options.verbose,
 		promptRetries: task.promptRetries ?? options.promptRetries ?? 0,
-		sessionOptions: mergeSessionOptions(task.sessionOptions, options.sessionOptions),
+		sessionOptions: task.sessionOptions,
 		onClientAvailable: options.onClientAvailable,
 		onClientClosed: options.onClientClosed,
 		onClientCloseFailure: options.onClientCloseFailure,
@@ -7016,6 +7200,7 @@ async function runOwnedSessionPrompt(options) {
 		verbose: options.verbose,
 		sessionOptions
 	});
+	const permissionStatsBefore = client.getPermissionStats();
 	client.updateRuntimeOptions({
 		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
@@ -7094,6 +7279,7 @@ async function runOwnedSessionPrompt(options) {
 					client,
 					record,
 					resumePolicy: options.resumePolicy,
+					sessionOptions: options.sessionOptions,
 					replacingConfigOption: requestedModelId(options.sessionOptions?.model) ? { key: "model" } : void 0,
 					timeoutMs: options.timeoutMs,
 					verbose: options.verbose,
@@ -7171,7 +7357,7 @@ async function runOwnedSessionPrompt(options) {
 		applyConversation(record, conversation);
 		const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
 		attachAcpErrorPayload(propagated, normalizedError.acp);
-		propagated.outputAlreadyEmitted = matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted;
+		markOutputAlreadyEmitted(propagated, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
 		propagated.normalizedOutputError = normalizedError;
 		throw propagated;
 	};
@@ -7198,8 +7384,10 @@ async function runOwnedSessionPrompt(options) {
 		record.lastUsedAt = now;
 		record.closed = false;
 		record.closedAt = void 0;
-		record.protocolVersion = client.initializeResult?.protocolVersion;
-		record.agentCapabilities = client.initializeResult?.agentCapabilities;
+		if (client.initializeResult) {
+			record.protocolVersion = client.initializeResult.protocolVersion;
+			record.agentCapabilities = client.initializeResult.agentCapabilities;
+		}
 		applyConversation(record, conversation);
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		stopTotalTimer();
@@ -7209,22 +7397,27 @@ async function runOwnedSessionPrompt(options) {
 		options.ownedSignal?.throwIfAborted();
 		const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
 		options.ownedSignal?.throwIfAborted();
-		await applyPromptModelIfAdvertised({
-			client,
-			sessionId: activeSessionId,
-			requestedModel: options.sessionOptions?.model,
-			record,
-			timeoutMs: options.timeoutMs,
-			suppressWarnings: options.suppressSdkConsoleErrors,
-			signal: options.ownedSignal
-		});
+		try {
+			await applyPromptModelIfAdvertised({
+				client,
+				sessionId: activeSessionId,
+				requestedModel: options.sessionOptions?.model,
+				record,
+				timeoutMs: options.timeoutMs,
+				suppressWarnings: options.suppressSdkConsoleErrors,
+				signal: options.ownedSignal
+			});
+		} catch (error) {
+			if (error instanceof TimeoutError) closeClientOnExit = true;
+			throw error;
+		}
 		options.ownedSignal?.throwIfAborted();
 		output.setContext({ sessionId: record.acpxRecordId });
 		await liveCheckpoint.checkpoint();
 		const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
 		promptTurnActive = false;
 		return {
-			...toPromptResult(response.stopReason, record.acpxRecordId, client, response._meta),
+			...toPromptResult(response.stopReason, record.acpxRecordId, client, permissionStatsBefore, response._meta),
 			record,
 			resumed,
 			loadError
@@ -7310,6 +7503,7 @@ async function runOnce(options, control) {
 	let promptTurnActive = false;
 	let promptTurnHadSideEffects = false;
 	let controlState = {};
+	let sawOwnedModelConfig = false;
 	const acpErrors = new AcpErrorTracker();
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
@@ -7330,7 +7524,10 @@ async function runOnce(options, control) {
 			acpErrors.observe(output, direction, message);
 		},
 		onSessionUpdate: (notification) => {
-			if (notification.update.sessionUpdate === "config_option_update") controlState = applyConfigOptionsToState(controlState, notification.update.configOptions);
+			if (notification.update.sessionUpdate === "config_option_update" && client.hasReusableSession(notification.sessionId)) {
+				controlState = applyConfigOptionsToState(controlState, notification.update.configOptions);
+				sawOwnedModelConfig ||= controlState.model_control === "config_option";
+			}
 			if (promptTurnActive) promptTurnHadSideEffects = true;
 			options.onSessionUpdate?.(notification);
 		},
@@ -7344,7 +7541,13 @@ async function runOnce(options, control) {
 		},
 		sessionOptions: options.sessionOptions
 	});
+	const permissionStatsBefore = client.getPermissionStats();
 	const closeOwnedClient = ownDirectClient(client, control?.signal);
+	const initializeControlState = (createdSession) => {
+		const configOptions = controlState.config_options ?? createdSession.configOptions ?? [];
+		if (createdSession.models && !sawOwnedModelConfig) applyAdvertisedModelState(controlState, createdSession.models);
+		controlState = applyConfigOptionsToState(controlState, configOptions);
+	};
 	const runExecPromptAttempt = async (sessionId) => {
 		assertControlAuthority(authority);
 		acpErrors.reset();
@@ -7377,29 +7580,34 @@ async function runOnce(options, control) {
 				});
 				assertControlAuthority(authority);
 				const sessionId = createdSession.sessionId;
-				if (createdSession.models) applyAdvertisedModelState(controlState, createdSession.models);
-				controlState = applyConfigOptionsToState(controlState, createdSession.configOptions ?? []);
+				initializeControlState(createdSession);
 				const modelApplication = await applyRequestedModelIfAdvertised({
 					client,
 					sessionId,
 					requestedModel: options.sessionOptions?.model,
-					models: createdSession.models,
+					models: advertisedModelState(controlState),
 					agentCommand: options.agentCommand,
 					timeoutMs: options.timeoutMs,
 					authority,
 					onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 				});
-				if (modelApplication.response) controlState = applyConfigOptionsToState(controlState, modelApplication.response.configOptions);
+				if (modelApplication.applied) controlState = applyModelSelection(controlState, modelApplication.modelId, modelApplication.response, modelApplication.resolvedModelId);
 				for (const configOption of options.configOptions ?? []) {
 					assertControlAuthority(authority);
-					const response = await withTimeout(client.setSessionConfigOption(sessionId, configOption.configId, configOption.value, advertisedModelState(controlState), authority), options.timeoutMs);
-					controlState = applyConfigOptionsToState(controlState, response.configOptions);
+					const models = advertisedModelState(controlState);
+					const { modelConfigId, resolvedValue } = resolveRequestedConfigOption({
+						...configOption,
+						models,
+						agentCommand: options.agentCommand
+					});
+					const response = await withTimeout(client.setSessionConfigOption(sessionId, configOption.configId, configOption.value, models, authority), options.timeoutMs);
+					controlState = applyConfigOptionSelection(controlState, configOption.configId, configOption.value, response, modelConfigId, resolvedValue);
 				}
 				assertControlAuthority(authority);
 				output.setContext({ sessionId });
 				const response = await runExecPromptWithRetries(sessionId);
 				promptTurnActive = false;
-				return toPromptResult(response.stopReason, sessionId, client, response._meta);
+				return toPromptResult(response.stopReason, sessionId, client, permissionStatsBefore, response._meta);
 			},
 			handleInterrupt: async () => {
 				await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
@@ -7626,31 +7834,50 @@ function createLeaseHeartbeat(lease, shutdown) {
 	};
 }
 async function runSessionQueueOwner(options) {
-	const lease = await tryAcquireQueueOwnerLease(options.sessionId, {
-		path: options.mcpConfigPath,
-		fingerprint: options.mcpConfigFingerprint
-	});
-	if (!lease) return;
-	let runtimeFailure;
-	try {
-		await runQueueOwnerRuntime(options, lease);
-	} catch (error) {
-		runtimeFailure = { error };
-	}
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	let stopRequested = false;
+	let requestRuntimeStop;
+	const onSignal = () => {
+		stopRequested = true;
+		requestRuntimeStop?.();
+	};
 	try {
-		await releaseQueueOwnerLease(lease);
-	} catch (error) {
-		if (runtimeFailure) throw new AggregateError([runtimeFailure.error, error], "Queue owner shutdown failed", { cause: error });
-		throw error;
+		for (const signal of signals) process.on(signal, onSignal);
+		const lease = await tryAcquireQueueOwnerLease(options.sessionId, {
+			path: options.mcpConfigPath,
+			fingerprint: options.mcpConfigFingerprint
+		});
+		if (!lease) return;
+		let runtimeFailure;
+		try {
+			await runQueueOwnerRuntime(options, lease, (requestStop) => {
+				requestRuntimeStop = requestStop;
+				if (stopRequested) requestStop();
+			});
+		} catch (error) {
+			runtimeFailure = { error };
+		}
+		try {
+			await releaseQueueOwnerLease(lease);
+		} catch (error) {
+			if (runtimeFailure) throw new AggregateError([runtimeFailure.error, error], "Queue owner shutdown failed", { cause: error });
+			throw error;
+		}
+		if (runtimeFailure) throw runtimeFailure.error;
+	} finally {
+		for (const signal of signals) process.off(signal, onSignal);
 	}
-	if (runtimeFailure) throw runtimeFailure.error;
 }
 async function keepOwnerForPendingControls(controls, shutdown) {
 	if (shutdown.requested || !controls.hasPending) return false;
 	await controls.drainAdmitted();
 	return !shutdown.requested;
 }
-async function runQueueOwnerRuntime(options, lease) {
+async function runQueueOwnerRuntime(options, lease, bindStopRequest) {
 	const sessionRecord = await resolveSessionRecord(options.sessionId);
 	let owner;
 	let heartbeatTimer;
@@ -7724,13 +7951,8 @@ async function runQueueOwnerRuntime(options, lease) {
 		sessionId: options.sessionId,
 		verbose: options.verbose
 	});
-	const onSignal = () => {
-		shutdown.request();
-	};
+	bindStopRequest(shutdown.request);
 	const heartbeat = createLeaseHeartbeat(lease, shutdown);
-	process.once("SIGINT", onSignal);
-	process.once("SIGTERM", onSignal);
-	process.once("SIGHUP", onSignal);
 	try {
 		owner = await SessionQueueOwner.start(lease, {
 			cancelPrompt: async () => {
@@ -7812,9 +8034,6 @@ async function runQueueOwnerRuntime(options, lease) {
 			}
 		}
 	} finally {
-		process.off("SIGINT", onSignal);
-		process.off("SIGTERM", onSignal);
-		process.off("SIGHUP", onSignal);
 		await shutdown.shutdown();
 		await lease.updates;
 	}
@@ -7858,6 +8077,6 @@ async function sendSession(options) {
 }
 const queueOwnerRuntimeTestInternals = { queueOwnerExitIsFatal };
 //#endregion
-export { isRequestedModelUnsupportedError as $, applyInitialModelSelection as A, reconcileAgentSessionId as B, setSessionModeOnOwner as C, connectAndLoadSession as D, withConnectedSession as E, persistSessionOptions as F, recordPromptSubmission as G, cloneSessionConversation as H, sessionOptionsFromRecord as I, advertisedModelState as J, recordSessionUpdate as K, applyConversation as L, applyRequestedModelIfAdvertised as M, setDesiredModeId as N, applyConfigOptionSelection as O, normalizeSessionOptionShape as P, RequestedModelUnsupportedError as Q, applyLifecycleSnapshotToRecord as R, setSessionMode as S, setSessionModelOnOwner as T, createSessionConversation as U, cloneSessionAcpxState as V, recordClientOperation as W, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as X, AcpClient as Y, REQUESTED_MODEL_UNSUPPORTED_REASONS as Z, cancelSessionPrompt as _, runQueuedTask as a, isLegacyZedCodexAcpInvocation as at, setSessionConfigOption as b, LiveSessionCheckpoint as c, assertControlAuthority as ct, flushPerfMetricsCapture as d, getAcpxVersion as et, installPerfMetricsCapture as f, listAgentSessions as g, ensureSession as h, runOnce as i, listSessionEvents as it, applyModelSelection as j, applyConfigOptionsToRecord as k, runPromptTurn as l, withInterrupt as lt, createSessionWithClient as m, runSessionQueueOwner as n, DEFAULT_QUEUE_OWNER_TTL_MS as nt, sendSessionDirect as o, InterruptedError as ot, createSession as p, trimConversationForRuntime as q, sendSession as r, normalizeQueueOwnerTtlMs as rt, DISCARD_OUTPUT_FORMATTER as s, TimeoutError as st, queueOwnerRuntimeTestInternals as t, permissionModeSatisfies as tt, buildQueueOwnerArgOverride as u, withTimeout as ut, closeSession as v, setSessionModel as w, setSessionConfigOptionOnOwner as x, sessionControlTestInternals as y, createInitialSessionRecord as z };
+export { isRequestedModelUnsupportedError as $, applyInitialModelSelection as A, reconcileAgentSessionId as B, setSessionModeOnOwner as C, connectAndLoadSession as D, withConnectedSession as E, persistSessionOptions as F, recordSessionUpdate as G, createSessionConversation as H, sessionOptionsFromRecord as I, advertisedModelState as J, trimConversationForRuntime as K, applyConversation as L, applyRequestedModelIfAdvertised as M, setDesiredModeId as N, applyConfigOptionSelection as O, normalizeSessionOptionShape as P, RequestedModelUnsupportedError as Q, applyLifecycleSnapshotToRecord as R, setSessionMode as S, setSessionModelOnOwner as T, recordClientOperation as U, cloneSessionConversation as V, recordPromptSubmission as W, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as X, AcpClient as Y, REQUESTED_MODEL_UNSUPPORTED_REASONS as Z, cancelSessionPrompt as _, runQueuedTask as a, normalizeQueueOwnerTtlMs as at, setSessionConfigOption as b, LiveSessionCheckpoint as c, listSessionEvents as ct, flushPerfMetricsCapture as d, TimeoutError as dt, resolveRequestedConfigOption as et, installPerfMetricsCapture as f, assertControlAuthority as ft, listAgentSessions as g, ensureSession as h, runOnce as i, DEFAULT_QUEUE_OWNER_TTL_MS as it, applyModelSelection as j, applyConfigOptionsToRecord as k, runPromptTurn as l, isLegacyZedCodexAcpInvocation as lt, createSessionWithClient as m, withTimeout as mt, runSessionQueueOwner as n, getAcpxVersion as nt, sendSessionDirect as o, acquireSessionImport as ot, createSession as p, withInterrupt as pt, cloneSessionAcpxState as q, sendSession as r, permissionModeSatisfies as rt, DISCARD_OUTPUT_FORMATTER as s, acquireSessionScope as st, queueOwnerRuntimeTestInternals as t, resolveRequestedModelId as tt, buildQueueOwnerArgOverride as u, InterruptedError as ut, closeSession as v, setSessionModel as w, setSessionConfigOptionOnOwner as x, sessionControlTestInternals as y, createInitialSessionRecord as z };
 
-//# sourceMappingURL=queue-owner-runtime-W0lly6ap.js.map
+//# sourceMappingURL=queue-owner-runtime-C0wIYowh.js.map