acpx 0.19.2 → 0.19.3

package/dist/{queue-owner-runtime-W0lly6ap.js → queue-owner-runtime-Dhr4gxNE.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-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,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) {
@@ -1016,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
@@ -1066,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;
 }
@@ -1103,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);
@@ -1111,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 ?? {};
@@ -1622,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();
@@ -1673,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;
@@ -1689,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}`;
@@ -1753,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({
@@ -1889,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] });
 	}
@@ -2337,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();
@@ -2457,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(),
@@ -2674,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();
@@ -2685,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) {
@@ -2725,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 {
@@ -2743,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);
@@ -3731,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: {
@@ -3799,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;
@@ -4346,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);
@@ -4375,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)
 	};
 }
@@ -4393,25 +4660,35 @@ function applyConfigOptionsToRecord(record, result) {
 	if (!configOptions) return;
 	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
 }
-function applyInitialModelSelection(record, originalModels, requestedModel, modelApplication) {
+function applyInitialModelSelection(record, originalModels, modelApplication) {
 	applyConfigOptionsToRecord(record, modelApplication.response);
-	syncAdvertisedModelState(record, modelApplication.response ? modelStateFromConfigOptions(modelApplication.response.configOptions) : originalModels);
-	if (modelApplication.applied) setCurrentModelId(record, currentModelIdFromSetModelResponse(modelApplication.response, requestedModel));
+	syncAdvertisedModelState(record, modelApplication.response?.configOptions !== void 0 ? modelStateFromConfigOptions(modelApplication.response.configOptions) : originalModels);
+	if (modelApplication.applied) record.acpx = applyModelSelection(record.acpx, modelApplication.modelId, modelApplication.response);
 }
-function applyAcceptedConfigOptions(state, response) {
+function applyAcceptedConfigOptions(state, response, selection) {
 	const next = cloneSessionAcpxState(state) ?? {};
-	if (!response) return next;
+	if (response?.configOptions === void 0) {
+		const option = next.config_options?.find((entry) => entry.id === selection.configId);
+		if (option) option.currentValue = selection.value;
+		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;
+	reconcileDesiredConfigOptions(next, response.configOptions);
 	return next;
 }
+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) {
 	const modelConfigId = advertisedModelState(state)?.configId;
-	const next = applyAcceptedConfigOptions(state, response);
+	const next = applyAcceptedConfigOptions(state, response, {
+		configId: modelConfigId,
+		value: modelId
+	});
 	next.session_options = {
 		...next.session_options,
 		model: modelId
@@ -4427,235 +4704,10 @@ function applyConfigOptionSelection(state, configId, value, response, modelConfi
 		...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;
-		}
-	}
-}
-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) {
-	const requestedPath = sessionEventLockPath(recordId);
-	await fs$1.mkdir(path.dirname(requestedPath), {
-		recursive: true,
-		mode: 448
+	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
@@ -4757,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,
@@ -4788,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) {
@@ -4823,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());
@@ -5577,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;
@@ -5632,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,
@@ -5719,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 {
@@ -6503,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;
+			}
 		}
 	}
 };
@@ -6557,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();
@@ -6601,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 }
 	};
 }
@@ -6627,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;
@@ -6744,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,
@@ -7016,6 +7061,7 @@ async function runOwnedSessionPrompt(options) {
 		verbose: options.verbose,
 		sessionOptions
 	});
+	const permissionStatsBefore = client.getPermissionStats();
 	client.updateRuntimeOptions({
 		permissionMode: options.permissionMode,
 		nonInteractivePermissions: options.nonInteractivePermissions,
@@ -7094,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,
@@ -7171,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;
 	};
@@ -7224,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
@@ -7344,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);
@@ -7389,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);
@@ -7626,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;
@@ -7724,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 () => {
@@ -7812,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;
 	}
@@ -7858,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, 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, 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-W0lly6ap.js.map
+//# sourceMappingURL=queue-owner-runtime-Dhr4gxNE.js.map