acpx 0.19.1 → 0.19.3

package/dist/{queue-owner-runtime-C4OOosbo.js → queue-owner-runtime-Dhr4gxNE.js}

@@ -1,5 +1,5 @@
-import { $ as measurePerf, A as findGitRepositoryRoot, B as writeSessionRecord, Bt as PermissionDeniedError, C as getUnsupportedPromptContentMessage, D as textPrompt, Dt as OUTPUT_ERROR_ORIGINS, E as promptToDisplayText, Et as OUTPUT_ERROR_CODES, Ft as AgentStartupError, G as normalizeAgentSessionId, Gt as SessionModelReplayError, Ht as QueueConnectionError, I as normalizeName, It as AuthPolicyError, Jt as UnsupportedPromptContentError, K as SESSION_JOURNAL_SCHEMA, Lt as ClaudeAcpSessionCreateTimeoutError, M as findSessionByDirectoryWalk, Mt as AcpxOperationalError, N as isoNow$1, Nt as AgentDisconnectedError, Pt as AgentSpawnError, Q as incrementPerfCounter, Rt as CopilotAcpUnsupportedError, St as isAcpResourceNotFoundError, Ut as SessionConfigOptionReplayError, Vt as PermissionPromptUnavailableError, W as extractAgentSessionId, Wt as SessionModeReplayError, X as formatPerfMetric, Z as getPerfMetricsSnapshot, _ as waitMs$1, a as trySetModelOnRunningOwner, at as isAcpJsonRpcMessage, b as lockOwnerPid, bt as extractAcpError, c as queueRequestExceedsLimit, et as recordPerfDuration, f as refreshQueueOwnerLease, ft as defaultSessionEventLog, g as tryAcquireQueueOwnerLease, gt as sessionEventSegmentPath, h as terminateQueueOwnerForSession, ht as sessionEventLockPath, i as trySetModeOnRunningOwner, k as absolutePath, l as parseQueueRequest, m as terminateProcess, mt as sessionEventActivePath, n as tryCloseSessionOnRunningOwner, nt as setPerfGauge, o as trySubmitToRunningOwner, ot as isAcpMessageObject, p as releaseQueueOwnerLease, pt as sessionBaseDir, q as SessionJournalReader, qt as SessionResumeRequiredError, r as trySetConfigOptionOnRunningOwner, rt as startPerfTimer, s as queueRequestByteLimit, st as isSessionUpdateNotification, t as tryCancelOnRunningOwner, tt as resetPerfMetrics, v as QueueLeaseGuardSettlementError, wt as EXIT_CODES, x as ProcessDescendants, xt as formatUnknownErrorMessage, y as createLockOwner, yt as isProcessAlive, z as resolveSessionRecord, zt as GeminiAcpStartupTimeoutError } from "./ipc-DAApJ5mi.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-BW06Pbb8.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-DWnqUICY.js";
 import fs, { readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
@@ -8,145 +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";
-import net from "node:net";
-//#region src/acp/error-normalization.ts
-const AUTH_REQUIRED_ACP_CODES = /* @__PURE__ */ new Set([-32e3]);
-const QUERY_CLOSED_BEFORE_RESPONSE_DETAIL = "query closed before response received";
-function asRecord$3(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	return value;
-}
-function isAuthRequiredMessage(value) {
-	if (!value) return false;
-	const normalized = value.toLowerCase();
-	return [
-		"auth required",
-		"authentication required",
-		"authorization required",
-		"credential required",
-		"credentials required",
-		"token required",
-		"login required"
-	].some((needle) => normalized.includes(needle));
-}
-function isAcpAuthRequiredPayload(acp) {
-	if (!acp) return false;
-	if (!AUTH_REQUIRED_ACP_CODES.has(acp.code)) return false;
-	if (isAuthRequiredMessage(acp.message)) return true;
-	const data = asRecord$3(acp.data);
-	if (!data) return false;
-	return hasAuthRequiredData(data);
-}
-function hasAuthRequiredData(data) {
-	return data.authRequired === true || hasNonEmptyString(data.methodId) || hasNonEmptyArray(data.methods);
-}
-function hasNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function hasNonEmptyArray(value) {
-	return Array.isArray(value) && value.length > 0;
-}
-function isOutputErrorCode(value) {
-	return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
-}
-function isOutputErrorOrigin(value) {
-	return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
-}
-function readOutputErrorMeta(error) {
-	const record = asRecord$3(error);
-	if (!record) return {};
-	return {
-		outputCode: isOutputErrorCode(record.outputCode) ? record.outputCode : void 0,
-		detailCode: typeof record.detailCode === "string" && record.detailCode.trim().length > 0 ? record.detailCode : void 0,
-		origin: isOutputErrorOrigin(record.origin) ? record.origin : void 0,
-		retryable: typeof record.retryable === "boolean" ? record.retryable : void 0,
-		acp: extractAcpError(record.acp)
-	};
-}
-function isTimeoutLike(error) {
-	return error instanceof Error && error.name === "TimeoutError";
-}
-function isNoSessionLike(error) {
-	return error instanceof Error && error.name === "NoSessionError";
-}
-function isUsageLike(error) {
-	if (!(error instanceof Error)) return false;
-	return error.name === "CommanderError" || error.name === "InvalidArgumentError" || asRecord$3(error)?.code === "commander.invalidArgument";
-}
-function formatErrorMessage(error) {
-	return formatUnknownErrorMessage(error);
-}
-function isAcpQueryClosedBeforeResponseError(error) {
-	const acp = extractAcpError(error);
-	if (!acp || acp.code !== -32603) return false;
-	const details = asRecord$3(acp.data)?.details;
-	if (typeof details !== "string") return false;
-	return details.toLowerCase().includes(QUERY_CLOSED_BEFORE_RESPONSE_DETAIL);
-}
-function mapErrorCode(error) {
-	if (error instanceof PermissionPromptUnavailableError) return "PERMISSION_PROMPT_UNAVAILABLE";
-	if (error instanceof PermissionDeniedError) return "PERMISSION_DENIED";
-	if (isTimeoutLike(error)) return "TIMEOUT";
-	if (isNoSessionLike(error) || isAcpResourceNotFoundError(error)) return "NO_SESSION";
-	if (isUsageLike(error)) return "USAGE";
-}
-function normalizeOutputError(error, options = {}) {
-	const meta = readOutputErrorMeta(error);
-	const code = resolveOutputErrorCode(error, options, meta);
-	const acp = options.acp ?? meta.acp ?? extractAcpError(error);
-	return {
-		code,
-		message: formatErrorMessage(error),
-		detailCode: resolveDetailCode(error, acp, options, meta),
-		origin: meta.origin ?? options.origin,
-		retryable: meta.retryable ?? options.retryable,
-		acp
-	};
-}
-function resolveOutputErrorCode(error, options, meta) {
-	const code = meta.outputCode ?? mapErrorCode(error) ?? options.defaultCode ?? "RUNTIME";
-	if (code === "RUNTIME" && isAcpResourceNotFoundError(error)) return "NO_SESSION";
-	return code;
-}
-function resolveDetailCode(error, acp, options, meta) {
-	return meta.detailCode ?? options.detailCode ?? (error instanceof AuthPolicyError || isAcpAuthRequiredPayload(acp) ? "AUTH_REQUIRED" : void 0);
-}
-/**
-* Returns true when an error from `client.prompt()` looks transient and
-* can reasonably be retried (e.g. model-API 400/500, network hiccups that
-* surface as ACP internal errors).
-*
-* Errors that are definitively non-recoverable (auth, missing session,
-* invalid params, timeout, permission) return false.
-*/
-function isRetryablePromptError(error) {
-	if (isNonRetryablePromptError(error)) return false;
-	const acp = extractAcpError(error);
-	if (!acp) return false;
-	return acp.code === -32603 || acp.code === -32700;
-}
-function isNonRetryablePromptError(error) {
-	return error instanceof PermissionDeniedError || error instanceof PermissionPromptUnavailableError || isTimeoutLike(error) || isNoSessionLike(error) || isUsageLike(error);
-}
-function exitCodeForOutputErrorCode(code) {
-	switch (code) {
-		case "USAGE": return EXIT_CODES.USAGE;
-		case "TIMEOUT": return EXIT_CODES.TIMEOUT;
-		case "NO_SESSION": return EXIT_CODES.NO_SESSION;
-		case "PERMISSION_DENIED":
-		case "PERMISSION_PROMPT_UNAVAILABLE": return EXIT_CODES.PERMISSION_DENIED;
-		default: return EXIT_CODES.ERROR;
-	}
-}
-//#endregion
 //#region src/async-control.ts
 var TimeoutError = class extends Error {
 	constructor(timeoutMs) {
@@ -477,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) {
@@ -1147,10 +1256,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
@@ -1197,7 +1306,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;
 }
@@ -1234,7 +1343,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);
@@ -1242,7 +1351,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 ?? {};
@@ -1753,7 +1865,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();
@@ -1804,6 +1916,7 @@ var TerminalManager = class {
 	processHelperTimeoutMs;
 	outputCeilingBytes;
 	terminals = /* @__PURE__ */ new Map();
+	creations = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.outputCeilingBytes = readTerminalOutputCeiling();
 		this.cwd = options.cwd;
@@ -1820,7 +1933,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}`;
@@ -1884,10 +2005,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({
@@ -2020,11 +2146,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] });
 	}
@@ -2468,8 +2596,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();
@@ -2588,14 +2717,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(),
@@ -2805,6 +2934,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();
@@ -2816,7 +2949,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) {
@@ -2856,7 +2989,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 {
@@ -2874,7 +3008,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);
@@ -3862,6 +3997,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: {
@@ -3930,7 +4066,10 @@ function appendAgentThinking(agent, text) {
 }
 function trimRuntimeText(value, maxChars) {
 	if (value.length <= maxChars) return value;
-	return `${value.slice(0, Math.max(0, maxChars - 3))}...`;
+	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 statusIndicatesComplete(status) {
 	if (typeof status !== "string") return false;
@@ -4477,13 +4616,6 @@ 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);
@@ -4506,9 +4638,13 @@ async function applyRequestedModelIfAdvertised(params) {
 	});
 	if (warning) params.onWarning?.(warning);
 	if (!params.models) return { applied: false };
-	if (params.models.currentModelId === requestedModel) return { applied: true };
+	if (params.models.currentModelId === requestedModel) return {
+		applied: true,
+		modelId: requestedModel
+	};
 	return {
 		applied: true,
+		modelId: requestedModel,
 		response: await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, params.models, params.authority), params.timeoutMs)
 	};
 }
@@ -4517,276 +4653,61 @@ async function applyRequestedModelIfAdvertised(params) {
 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
-			});
-		}
-	});
-}
-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;
-		}
-	}
+	return acpxState;
 }
-async function disposeTurn(filePath, receipt) {
-	if (!await settleTurn(filePath, receipt)) throw new Error(`Session turn cleanup is waiting for its guard: ${filePath}`);
+function applyConfigOptionsToRecord(record, result) {
+	const configOptions = result?.configOptions;
+	if (!configOptions) return;
+	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
 }
-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 applyInitialModelSelection(record, originalModels, modelApplication) {
+	applyConfigOptionsToRecord(record, modelApplication.response);
+	syncAdvertisedModelState(record, modelApplication.response?.configOptions !== void 0 ? modelStateFromConfigOptions(modelApplication.response.configOptions) : originalModels);
+	if (modelApplication.applied) record.acpx = applyModelSelection(record.acpx, modelApplication.modelId, modelApplication.response);
 }
-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;
+function applyAcceptedConfigOptions(state, response, selection) {
+	const next = cloneSessionAcpxState(state) ?? {};
+	if (response?.configOptions === void 0) {
+		const option = next.config_options?.find((entry) => entry.id === selection.configId);
+		if (option) option.currentValue = selection.value;
+		return next;
 	}
-	return receipt;
+	applyConfigOptionsModelState(next, response.configOptions);
+	reconcileDesiredConfigOptions(next, response.configOptions);
+	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 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;
 }
-async function acquireSessionTurn(recordId, signal) {
-	const requestedPath = sessionEventLockPath(recordId);
-	await fs$1.mkdir(path.dirname(requestedPath), {
-		recursive: true,
-		mode: 448
+function applyModelSelection(state, modelId, response) {
+	const modelConfigId = advertisedModelState(state)?.configId;
+	const next = applyAcceptedConfigOptions(state, response, {
+		configId: modelConfigId,
+		value: modelId
+	});
+	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, {
+		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
@@ -4813,406 +4734,6 @@ function directExecutionError(error, signal) {
 	return signal?.aborted && error instanceof AgentDisconnectedError ? signal.reason : error;
 }
 //#endregion
-//#region src/session/queue/ipc-server.ts
-const QUEUE_SOCKET_DRAIN_TIMEOUT_MS = 1e3;
-function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
-	return {
-		type: "error",
-		requestId,
-		ownerGeneration: void 0,
-		code: "RUNTIME",
-		detailCode,
-		origin: "queue",
-		retryable: options.retryable,
-		message
-	};
-}
-function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
-	const normalized = normalizeOutputError(error, {
-		defaultCode: "RUNTIME",
-		origin: "queue",
-		detailCode,
-		retryable: options.retryable
-	});
-	return {
-		type: "error",
-		requestId,
-		code: normalized.code,
-		detailCode: normalized.detailCode,
-		origin: normalized.origin,
-		message: normalized.message,
-		retryable: normalized.retryable,
-		acp: normalized.acp
-	};
-}
-function armSocketDrainTimeout(socket) {
-	if (process.platform !== "win32") socket.setTimeout(QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
-}
-function writeQueueMessage(socket, message) {
-	if (socket.destroyed || !socket.writable) return;
-	if (!socket.write(`${JSON.stringify(message)}\n`) && !socket.timeout) armSocketDrainTimeout(socket);
-}
-var SessionQueueOwner = class SessionQueueOwner {
-	server;
-	controlHandlers;
-	ownerGeneration;
-	maxQueueDepth;
-	maxRequestBytes;
-	onQueueDepthChanged;
-	pending = [];
-	activeTask;
-	waiters = [];
-	sockets = /* @__PURE__ */ new Set();
-	taskSockets = /* @__PURE__ */ new Set();
-	drainingSockets = /* @__PURE__ */ new Set();
-	closed = false;
-	constructor(server, controlHandlers, lease, options) {
-		this.server = server;
-		this.controlHandlers = controlHandlers;
-		this.ownerGeneration = lease.ownerGeneration;
-		this.maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth));
-		this.maxRequestBytes = queueRequestByteLimit(options.maxRequestBytes?.toString());
-		this.onQueueDepthChanged = options.onQueueDepthChanged;
-	}
-	static async start(lease, controlHandlers, options = { maxQueueDepth: 16 }) {
-		const ownerRef = { current: void 0 };
-		const server = net.createServer((socket) => {
-			ownerRef.current?.handleConnection(socket);
-		});
-		ownerRef.current = new SessionQueueOwner(server, controlHandlers, lease, options);
-		await new Promise((resolve, reject) => {
-			const onListening = () => {
-				server.off("error", onError);
-				resolve();
-			};
-			const onError = (error) => {
-				server.off("listening", onListening);
-				reject(error);
-			};
-			server.once("listening", onListening);
-			server.once("error", onError);
-			server.listen(lease.socketPath);
-		});
-		return ownerRef.current;
-	}
-	beginShutdown() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const waiter of this.waiters.splice(0)) waiter(void 0);
-		for (const task of this.pending.splice(0)) {
-			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner shutting down before prompt execution", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
-			task.close();
-		}
-		for (const socket of this.sockets) if (!this.taskSockets.has(socket) && !this.drainingSockets.has(socket)) socket.destroy();
-		this.emitQueueDepth();
-	}
-	async close() {
-		this.beginShutdown();
-		await new Promise((resolve) => {
-			const forceCloseTimer = setTimeout(() => {
-				for (const socket of this.sockets) socket.destroy();
-			}, QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
-			forceCloseTimer.unref();
-			this.server.close(() => {
-				clearTimeout(forceCloseTimer);
-				resolve();
-			});
-		});
-	}
-	async nextTask(timeoutMs) {
-		if (this.pending.length > 0) {
-			const task = this.pending.shift();
-			this.emitQueueDepth();
-			if (task) {
-				this.activeTask = task;
-				recordPerfDuration("queue.owner.wait_ms", Date.now() - task.enqueuedAt);
-			}
-			return task;
-		}
-		if (this.closed) return;
-		return await new Promise((resolve) => {
-			const timer = timeoutMs != null && setTimeout(() => {
-				const index = this.waiters.indexOf(waiter);
-				if (index >= 0) this.waiters.splice(index, 1);
-				resolve(void 0);
-			}, Math.max(0, timeoutMs));
-			const waiter = (task) => {
-				if (timer) clearTimeout(timer);
-				resolve(task);
-			};
-			this.waiters.push(waiter);
-		});
-	}
-	queueDepth() {
-		return this.pending.length;
-	}
-	completeTask(task) {
-		if (this.activeTask === task) this.activeTask = void 0;
-	}
-	async cancelPrompt(targetRequestId) {
-		if (targetRequestId === void 0) return await this.controlHandlers.cancelPrompt();
-		const index = this.pending.findIndex((task) => task.requestId === targetRequestId);
-		if (index >= 0) {
-			const [task] = this.pending.splice(index, 1);
-			task.send(makeQueueOwnerError(task.requestId, "Prompt cancelled before execution", "QUEUE_REQUEST_CANCELLED", { retryable: false }));
-			task.close();
-			this.emitQueueDepth();
-			return true;
-		}
-		return this.activeTask?.requestId === targetRequestId ? await this.controlHandlers.cancelPrompt() : false;
-	}
-	emitQueueDepth() {
-		this.onQueueDepthChanged?.(this.pending.length);
-	}
-	enqueue(task) {
-		if (this.closed) {
-			task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
-			task.close();
-			return false;
-		}
-		if (this.activeTask?.requestId === task.requestId || this.pending.some((queued) => queued.requestId === task.requestId)) {
-			task.send(makeQueueOwnerError(task.requestId, "Request is already queued or active", "QUEUE_REQUEST_DUPLICATE", { retryable: false }));
-			task.close();
-			return false;
-		}
-		const waiter = this.waiters.shift();
-		if (waiter) {
-			this.activeTask = task;
-			waiter(task);
-			return true;
-		}
-		if (this.pending.length >= this.maxQueueDepth) {
-			task.send({
-				...makeQueueOwnerError(task.requestId, `Queue owner is overloaded (${this.pending.length}/${this.maxQueueDepth} queued)`, "QUEUE_OWNER_OVERLOADED", { retryable: true }),
-				ownerGeneration: this.ownerGeneration
-			});
-			task.close();
-			return false;
-		}
-		this.pending.push(task);
-		this.emitQueueDepth();
-		return true;
-	}
-	handleControlRequest(options) {
-		this.taskSockets.add(options.socket);
-		writeQueueMessage(options.socket, {
-			type: "accepted",
-			requestId: options.requestId,
-			ownerGeneration: this.ownerGeneration
-		});
-		options.run().then((message) => {
-			writeQueueMessage(options.socket, {
-				...message,
-				ownerGeneration: this.ownerGeneration
-			});
-		}).catch((error) => {
-			writeQueueMessage(options.socket, {
-				...makeQueueOwnerErrorFromUnknown(options.requestId, error, "QUEUE_CONTROL_REQUEST_FAILED"),
-				ownerGeneration: this.ownerGeneration
-			});
-		}).finally(() => {
-			this.endSocket(options.socket);
-		});
-	}
-	endSocket(socket) {
-		if (socket.destroyed || this.drainingSockets.has(socket)) return;
-		this.taskSockets.delete(socket);
-		this.drainingSockets.add(socket);
-		armSocketDrainTimeout(socket);
-		socket.end(() => {
-			this.drainingSockets.delete(socket);
-			socket.destroy();
-		});
-	}
-	failRequest(socket, requestId, message, detailCode) {
-		writeQueueMessage(socket, {
-			...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
-			ownerGeneration: this.ownerGeneration
-		});
-		this.endSocket(socket);
-	}
-	parseRequestLine(socket, line) {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			this.failRequest(socket, "unknown", "Invalid queue request payload", "QUEUE_REQUEST_PAYLOAD_INVALID_JSON");
-			return;
-		}
-		const request = parseQueueRequest(parsed);
-		if (!request) this.failRequest(socket, "unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
-		return request ?? void 0;
-	}
-	rejectStaleOwnerGeneration(socket, request) {
-		if (request.ownerGeneration === void 0 || this.ownerGeneration === void 0 || request.ownerGeneration === this.ownerGeneration) return false;
-		this.failRequest(socket, request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
-		return true;
-	}
-	rejectClosedOwner(socket, request) {
-		if (!this.closed) return false;
-		writeQueueMessage(socket, {
-			...makeQueueOwnerError(request.requestId, "Queue owner is shutting down", "QUEUE_OWNER_CLOSED", { retryable: true }),
-			ownerGeneration: this.ownerGeneration
-		});
-		this.endSocket(socket);
-		return true;
-	}
-	handleControlQueueRequest(socket, request) {
-		if (request.type === "cancel_prompt") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "cancel_result",
-					requestId: request.requestId,
-					cancelled: await this.cancelPrompt(request.targetRequestId)
-				})
-			});
-			return true;
-		}
-		if (request.type === "close_session") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "close_session_result",
-					requestId: request.requestId,
-					closed: await this.controlHandlers.closeSession(request.timeoutMs)
-				})
-			});
-			return true;
-		}
-		return this.handleSessionControlQueueRequest(socket, request);
-	}
-	handleSessionControlQueueRequest(socket, request) {
-		if (request.type === "set_mode") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => {
-					await this.controlHandlers.setSessionMode(request.modeId, request.timeoutMs);
-					return {
-						type: "set_mode_result",
-						requestId: request.requestId,
-						modeId: request.modeId
-					};
-				}
-			});
-			return true;
-		}
-		if (request.type === "set_model") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => {
-					const response = await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
-					return {
-						type: "set_model_result",
-						requestId: request.requestId,
-						modelId: request.modelId,
-						response
-					};
-				}
-			});
-			return true;
-		}
-		if (request.type === "set_config_option") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "set_config_option_result",
-					requestId: request.requestId,
-					response: await this.controlHandlers.setSessionConfigOption(request.configId, request.value, request.timeoutMs)
-				})
-			});
-			return true;
-		}
-		return false;
-	}
-	enqueuePromptRequest(socket, request) {
-		this.taskSockets.add(socket);
-		const task = {
-			requestId: request.requestId,
-			message: request.message,
-			prompt: request.prompt ?? textPrompt(request.message),
-			permissionMode: request.permissionMode,
-			resumePolicy: request.resumePolicy,
-			nonInteractivePermissions: request.nonInteractivePermissions,
-			permissionPolicy: request.permissionPolicy,
-			timeoutMs: request.timeoutMs,
-			suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
-			promptRetries: request.promptRetries,
-			sessionOptions: request.sessionOptions,
-			waitForCompletion: request.waitForCompletion,
-			reportPromptStarted: request.reportPromptStarted,
-			enqueuedAt: Date.now(),
-			send: (message) => {
-				writeQueueMessage(socket, {
-					...message,
-					ownerGeneration: this.ownerGeneration
-				});
-			},
-			close: () => {
-				this.endSocket(socket);
-			}
-		};
-		if (!this.enqueue(task)) return;
-		writeQueueMessage(socket, {
-			type: "accepted",
-			requestId: request.requestId,
-			ownerGeneration: this.ownerGeneration
-		});
-		if (!request.waitForCompletion) task.close();
-	}
-	handleConnection(socket) {
-		this.sockets.add(socket);
-		socket.setEncoding("utf8");
-		socket.on("timeout", () => socket.destroy());
-		socket.on("drain", () => {
-			if (!socket.writableEnded) socket.setTimeout(0);
-		});
-		socket.once("close", () => {
-			this.sockets.delete(socket);
-			this.taskSockets.delete(socket);
-			this.drainingSockets.delete(socket);
-		});
-		let buffer = "";
-		let handled = false;
-		const processLine = (line) => {
-			if (handled) return;
-			handled = true;
-			const request = this.parseRequestLine(socket, line);
-			if (!request || this.rejectClosedOwner(socket, request) || this.rejectStaleOwnerGeneration(socket, request)) return;
-			if (this.handleControlQueueRequest(socket, request)) return;
-			if (request.type !== "submit_prompt") {
-				this.failRequest(socket, request.requestId, "Invalid queue request", "QUEUE_REQUEST_INVALID");
-				return;
-			}
-			this.enqueuePromptRequest(socket, request);
-		};
-		socket.on("data", (chunk) => {
-			buffer += chunk;
-			let index = buffer.indexOf("\n");
-			while (index >= 0) {
-				const rawLine = buffer.slice(0, index);
-				if (this.rejectOversizedRequest(socket, rawLine)) return;
-				const line = rawLine.trim();
-				buffer = buffer.slice(index + 1);
-				if (line.length > 0) processLine(line);
-				index = buffer.indexOf("\n");
-			}
-			this.rejectOversizedRequest(socket, buffer);
-		});
-		socket.on("error", () => {});
-	}
-	rejectOversizedRequest(socket, line) {
-		if (!queueRequestExceedsLimit(line, this.maxRequestBytes)) return false;
-		socket.destroy();
-		return true;
-	}
-};
-//#endregion
 //#region src/runtime/engine/reconnect.ts
 const SESSION_LOAD_UNSUPPORTED_CODES = /* @__PURE__ */ new Set([-32601, -32602]);
 function createReplayState(authority) {
@@ -5288,10 +4809,7 @@ async function replayDesiredModel(params) {
 		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
-		};
+		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,
@@ -5319,10 +4837,10 @@ async function replayDesiredConfigOptions(params) {
 			const response = await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value, advertisedModelState(params.record.acpx), params.replay.authority), params.timeoutMs);
 			params.replay.acknowledged = true;
 			params.record.acpx = applyConfigOptionSelection(params.record.acpx, configId, value, response);
-			acceptedConfigOptions = response.configOptions;
+			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) {
@@ -5354,7 +4872,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());
@@ -5798,6 +5316,89 @@ async function runSessionSetConfigOptionDirect(options) {
 	};
 }
 //#endregion
+//#region src/session/execution/windows-process-command.ts
+function skipSeparators(value) {
+	return value.replace(/^[ \t]+/u, "");
+}
+function readQuote(commandLine, state, executable) {
+	if (!executable && state.quoted && commandLine[state.index + 1] === "\"") {
+		state.value += "\"";
+		state.index += 2;
+	} else {
+		state.quoted = !state.quoted;
+		state.index += 1;
+	}
+}
+function readBackslashes(commandLine, state, executable) {
+	const start = state.index;
+	while (commandLine[state.index] === "\\") state.index += 1;
+	const count = state.index - start;
+	if (executable || commandLine[state.index] !== "\"") state.value += "\\".repeat(count);
+	else {
+		state.value += "\\".repeat(Math.floor(count / 2));
+		if (count % 2 === 1) {
+			state.value += "\"";
+			state.index += 1;
+		} else readQuote(commandLine, state, false);
+	}
+}
+function readArgument(commandLine, start, executable) {
+	const state = {
+		value: "",
+		index: start,
+		quoted: false
+	};
+	while (state.index < commandLine.length) {
+		const char = commandLine[state.index];
+		if (!state.quoted && /[ \t]/u.test(char)) break;
+		if (char === "\\") readBackslashes(commandLine, state, executable);
+		else if (char === "\"") readQuote(commandLine, state, executable);
+		else {
+			state.value += char;
+			state.index += 1;
+		}
+	}
+	return state.quoted ? void 0 : state;
+}
+function readBatchCommand(commandLine) {
+	const body = commandLine.match(/^[ \t]+\/d[ \t]+\/s[ \t]+\/c[ \t]+"([\s\S]*)"$/iu)?.[1];
+	if (!body) return;
+	return readBatchExecutable(body);
+}
+function readBatchExecutable(body) {
+	let command = "";
+	for (let index = 0; index < body.length; index += 1) {
+		const char = body[index];
+		if (char === "^") {
+			index += 1;
+			if (index === body.length) return;
+			command += body[index];
+		} else if (/[ \t]/u.test(char)) break;
+		else if (/["\r\n]/u.test(char)) return;
+		else command += char;
+	}
+	return /\.(?:cmd|bat)$/iu.test(command) ? command : void 0;
+}
+/** Decode process observations, not saved command identities or POSIX launch strings. */
+function splitWindowsProcessCommandLine(commandLine) {
+	const line = skipSeparators(commandLine);
+	const executable = readArgument(line, 0, true);
+	if (!executable?.value) return [];
+	const argv = [executable.value];
+	if (path.win32.basename(executable.value).toLowerCase() === "cmd.exe") {
+		const batch = readBatchCommand(line.slice(executable.index));
+		return batch ? [...argv, batch] : argv;
+	}
+	let rest = skipSeparators(line.slice(executable.index));
+	while (rest) {
+		const argument = readArgument(rest, 0, false);
+		if (!argument) return [];
+		argv.push(argument.value);
+		rest = skipSeparators(rest.slice(argument.index));
+	}
+	return argv;
+}
+//#endregion
 //#region src/session/execution/session-control.ts
 async function cancelSessionPrompt(options) {
 	const cancelled = await tryCancelOnRunningOwner(options);
@@ -5907,15 +5508,16 @@ async function setSessionConfigOption(options) {
 		verbose: options.verbose
 	});
 }
-function firstAgentCommandToken(command) {
+function firstAgentCommandToken(command, argv) {
+	if (argv) return argv[0] || void 0;
 	try {
 		return splitCommandLine(command).command || void 0;
 	} catch {
 		return;
 	}
 }
-async function isLikelyMatchingProcess(pid, agentCommand) {
-	const expectedToken = firstAgentCommandToken(agentCommand);
+async function isLikelyMatchingProcess(pid, record) {
+	const expectedToken = firstAgentCommandToken(record.agentCommand, record.agentArgv);
 	if (!expectedToken) return false;
 	const argv = await readProcessArgv(pid);
 	if (argv.length === 0) return false;
@@ -5954,13 +5556,14 @@ async function readWindowsCommandLine(pid) {
 			"-NonInteractive",
 			"-Command",
 			`(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
-		], { windowsHide: true })).trim() || void 0;
+		], { windowsHide: true })).replace(/\r?\n$/u, "") || void 0;
 	} catch {
 		return;
 	}
 }
-function splitCommandLineLike(commandLine) {
+function splitCommandLineLike(commandLine, platform = process.platform) {
 	if (!commandLine) return [];
+	if (platform === "win32") return splitWindowsProcessCommandLine(commandLine);
 	try {
 		const parsed = splitCommandLine(commandLine);
 		return [parsed.command, ...parsed.args];
@@ -5982,7 +5585,7 @@ async function closeSession(sessionId) {
 		}
 	}).catch(() => {});
 	if (selectedOwner) await terminateQueueOwnerForSession(record.acpxRecordId, selectedOwner);
-	if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record.agentCommand)) await terminateProcess(record.pid);
+	if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record)) await terminateProcess(record.pid);
 	const ownership = await acquireSessionTurn(record.acpxRecordId);
 	try {
 		const current = await resolveSessionRecord(record.acpxRecordId);
@@ -6023,7 +5626,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;
@@ -6078,6 +5681,14 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 }
 async function createSessionWithClient(options) {
 	assertControlAuthority({ signal: options.signal });
+	if (options.resumeSessionId) {
+		const resumedRecord = await readSessionRecord(options.resumeSessionId);
+		assertControlAuthority({ signal: options.signal });
+		if (resumedRecord && !resumedRecord.closed && resumedRecord.agentCommand === options.agentCommand) {
+			await closeSession(resumedRecord.acpxRecordId);
+			assertControlAuthority({ signal: options.signal });
+		}
+	}
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		agentArgv: options.agentArgv,
@@ -6165,11 +5776,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 {
@@ -6949,7 +6560,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;
+			}
 		}
 	}
 };
@@ -7003,8 +6619,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();
@@ -7047,11 +6663,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 }
 	};
 }
@@ -7073,60 +6695,37 @@ async function applyPromptModelIfAdvertised(params) {
 	});
 	if (result.applied) params.record.acpx = applyModelSelection(params.record.acpx, requestedModel, result.response);
 }
-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;
@@ -7190,7 +6789,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,
@@ -7462,6 +7061,7 @@ async function runOwnedSessionPrompt(options) {
 		verbose: options.verbose,
 		sessionOptions
 	});
+	const permissionStatsBefore = client.getPermissionStats();
 	client.updateRuntimeOptions({
 		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
@@ -7540,6 +7140,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,
@@ -7617,7 +7218,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;
 	};
@@ -7670,7 +7271,7 @@ async function runOwnedSessionPrompt(options) {
 		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
@@ -7790,6 +7391,7 @@ async function runOnce(options, control) {
 		},
 		sessionOptions: options.sessionOptions
 	});
+	const permissionStatsBefore = client.getPermissionStats();
 	const closeOwnedClient = ownDirectClient(client, control?.signal);
 	const runExecPromptAttempt = async (sessionId) => {
 		assertControlAuthority(authority);
@@ -7835,17 +7437,17 @@ async function runOnce(options, control) {
 					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);
 				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);
+					controlState = applyConfigOptionSelection(controlState, configOption.configId, configOption.value, response);
 				}
 				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);
@@ -8072,31 +7674,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;
@@ -8170,13 +7791,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 () => {
@@ -8258,9 +7874,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;
 	}
@@ -8304,6 +7917,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, exitCodeForOutputErrorCode as dt, getAcpxVersion as et, installPerfMetricsCapture as f, normalizeOutputError as ft, 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, 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, acquireSessionScope as at, setSessionConfigOption as b, LiveSessionCheckpoint as c, InterruptedError as ct, flushPerfMetricsCapture as d, withInterrupt as dt, getAcpxVersion as et, installPerfMetricsCapture as f, withTimeout as ft, listAgentSessions as g, ensureSession as h, runOnce as i, acquireSessionImport as it, applyModelSelection as j, applyConfigOptionsToRecord as k, runPromptTurn as l, TimeoutError as lt, createSessionWithClient as m, runSessionQueueOwner as n, DEFAULT_QUEUE_OWNER_TTL_MS as nt, sendSessionDirect as o, listSessionEvents as ot, createSession as p, trimConversationForRuntime as q, sendSession as r, normalizeQueueOwnerTtlMs as rt, DISCARD_OUTPUT_FORMATTER as s, isLegacyZedCodexAcpInvocation as st, queueOwnerRuntimeTestInternals as t, permissionModeSatisfies as tt, buildQueueOwnerArgOverride as u, assertControlAuthority as ut, closeSession as v, setSessionModel as w, setSessionConfigOptionOnOwner as x, sessionControlTestInternals as y, createInitialSessionRecord as z };
 
-//# sourceMappingURL=queue-owner-runtime-C4OOosbo.js.map
+//# sourceMappingURL=queue-owner-runtime-Dhr4gxNE.js.map