acpx 0.13.0 → 0.13.2

package/dist/{live-checkpoint-CBecfnSH.js → live-checkpoint-Gw2oGjhe.js}

@@ -6,9 +6,8 @@ import os from "node:os";
 import { randomUUID } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
-import { ClientSideConnection, PROTOCOL_VERSION, RequestError } from "@agentclientprotocol/sdk";
+import { PROTOCOL_VERSION, client, methods } from "@agentclientprotocol/sdk";
 import readline from "node:readline/promises";
-import { promisify } from "node:util";
 //#region src/errors.ts
 var AcpxOperationalError = class extends Error {
 	outputCode;
@@ -983,7 +982,7 @@ function parseJsonRpcErrorMessage(message) {
 }
 //#endregion
 //#region src/session/event-log.ts
-const DEFAULT_EVENT_SEGMENT_MAX_BYTES = 64 * 1024 * 1024;
+const DEFAULT_EVENT_SEGMENT_MAX_BYTES = 67108864;
 function sessionBaseDir$1() {
 	return path.join(os.homedir(), ".acpx", "sessions");
 }
@@ -1721,7 +1720,8 @@ function assertPersistedKeyPolicy(value) {
 //#endregion
 //#region src/session/persistence/atomic-write.ts
 function createAtomicWriteTempPath(filePath, createUniqueId = randomUUID) {
-	return `${filePath}.${process.pid}.${Date.now()}.${createUniqueId()}.tmp`;
+	const tempName = `.acpx-write.${process.pid}.${Date.now()}.${createUniqueId()}.tmp`;
+	return path.join(path.dirname(filePath), tempName);
 }
 //#endregion
 //#region src/session/persistence/index.ts
@@ -2068,7 +2068,7 @@ function toWritePreview(content) {
 	const visibleLines = lines.slice(0, WRITE_PREVIEW_MAX_LINES);
 	let preview = visibleLines.join("\n");
 	if (lines.length > visibleLines.length) preview += `\n... (${lines.length - visibleLines.length} more lines)`;
-	if (preview.length > WRITE_PREVIEW_MAX_CHARS) preview = `${preview.slice(0, WRITE_PREVIEW_MAX_CHARS - 3)}...`;
+	if (preview.length > WRITE_PREVIEW_MAX_CHARS) preview = `${preview.slice(0, 1197)}...`;
 	return preview;
 }
 async function defaultConfirmWrite(filePath, preview) {
@@ -2633,9 +2633,41 @@ function getAcpxVersion() {
 	cachedVersion = resolveAcpxVersion();
 	return cachedVersion;
 }
-//#endregion
-//#region src/acp/client-process.ts
-const execFileAsync = promisify(execFile);
+async function runTimedExecFile(command, args, options = {}) {
+	const timeoutMs = Math.max(1, Math.round(options.timeoutMs ?? 8e3));
+	return await new Promise((resolve, reject) => {
+		let settled = false;
+		let timer;
+		const child = execFile(command, [...args], {
+			encoding: "utf8",
+			maxBuffer: options.maxBufferBytes ?? 33554432,
+			killSignal: "SIGKILL",
+			windowsHide: options.windowsHide
+		}, (error, stdout) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve(stdout);
+		});
+		timer = setTimeout(() => {
+			if (settled) return;
+			settled = true;
+			const killed = child.kill("SIGKILL");
+			child.stdout?.destroy();
+			child.stderr?.destroy();
+			child.unref();
+			reject(Object.assign(/* @__PURE__ */ new Error(`${command} timed out after ${timeoutMs}ms`), {
+				code: "ETIMEDOUT",
+				killed,
+				signal: "SIGKILL"
+			}));
+		}, timeoutMs);
+	});
+}
 function normalizeAgentCommandInput(value) {
 	if (typeof value === "string") return { agentCommand: value };
 	const parts = toCommandParts([...value]);
@@ -2832,8 +2864,7 @@ function isWindowsExecutableCommand(command) {
 	return WINDOWS_EXECUTABLE_EXTENSION_RE.test(normalized);
 }
 async function runWslpath(cwd) {
-	const { stdout } = await execFileAsync("wslpath", ["-w", cwd], { encoding: "utf8" });
-	return stdout;
+	return await runTimedExecFile("wslpath", ["-w", cwd]);
 }
 function basenameToken(value) {
 	return path.basename(value).toLowerCase().replace(/\.(cmd|exe|bat)$/u, "");
@@ -3307,7 +3338,7 @@ function maybeWrapSessionControlError(method, error, context) {
 }
 //#endregion
 //#region src/acp/terminal-manager.ts
-const DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES = 64 * 1024;
+const DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES = 65536;
 const DEFAULT_KILL_GRACE_MS = 1500;
 function nowIso() {
 	return (/* @__PURE__ */ new Date()).toISOString();
@@ -3376,6 +3407,7 @@ var TerminalManager = class {
 	usesDefaultConfirmExecute;
 	confirmExecute;
 	killGraceMs;
+	processHelperTimeoutMs;
 	terminals = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.cwd = options.cwd;
@@ -3385,6 +3417,7 @@ var TerminalManager = class {
 		this.usesDefaultConfirmExecute = options.confirmExecute == null;
 		this.confirmExecute = options.confirmExecute ?? defaultConfirmExecute;
 		this.killGraceMs = Math.max(0, Math.round(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS));
+		this.processHelperTimeoutMs = Math.max(1, Math.round(options.processHelperTimeoutMs ?? 8e3));
 	}
 	updatePermissionPolicy(permissionMode, nonInteractivePermissions) {
 		this.permissionMode = permissionMode;
@@ -3411,6 +3444,7 @@ var TerminalManager = class {
 				process: proc,
 				killProcessGroup: spawnCommand.killProcessGroup,
 				descendantPids: /* @__PURE__ */ new Set(),
+				processHelperTimeoutMs: this.processHelperTimeoutMs,
 				output: Buffer.alloc(0),
 				truncated: false,
 				outputByteLimit,
@@ -3636,7 +3670,7 @@ var TerminalManager = class {
 	}
 	async captureDescendantPids(terminal, pid) {
 		if (!this.isRunning(terminal)) await terminal.processGroupSnapshotPromise?.catch(() => {});
-		for (const descendantPid of await listDescendantPids(pid)) terminal.descendantPids.add(descendantPid);
+		for (const descendantPid of await listDescendantPids(pid, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(descendantPid);
 	}
 	async waitForCleanupAfterSignal(terminal) {
 		return await Promise.race([this.waitForTerminalAndTrackedDescendants(terminal).then(() => true), waitMs(this.killGraceMs).then(() => false)]);
@@ -3689,10 +3723,10 @@ function commandPathExists(command, cwd) {
 	const resolvedPath = path.isAbsolute(command) ? command : path.resolve(cwd, command);
 	return fs.existsSync(resolvedPath);
 }
-async function listDescendantPids(rootPid) {
+async function listDescendantPids(rootPid, timeoutMs) {
 	let output;
 	try {
-		output = await runProcessListCommand();
+		output = await runProcessListCommand(timeoutMs);
 	} catch {
 		return [];
 	}
@@ -3725,47 +3759,23 @@ function parseProcessListLine(line) {
 		parentPid
 	};
 }
-async function runProcessListCommand() {
-	if (process.platform === "win32") return await runWindowsProcessListCommand();
-	return await new Promise((resolve, reject) => {
-		const child = spawn("ps", ["-eo", "pid=,ppid="], { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`ps exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
-	});
+async function runProcessListCommand(timeoutMs) {
+	if (process.platform === "win32") return await runWindowsProcessListCommand(timeoutMs);
+	return await runTimedExecFile("ps", ["-eo", "pid=,ppid="], { timeoutMs });
 }
 async function rememberProcessGroupPids(terminal) {
 	const processGroupId = terminal.process.pid;
 	if (!terminal.killProcessGroup || !processGroupId) return;
 	if (process.platform === "win32") {
-		for (const pid of await listDescendantPids(processGroupId)) terminal.descendantPids.add(pid);
+		for (const pid of await listDescendantPids(processGroupId, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(pid);
 		return;
 	}
-	for (const pid of await listProcessGroupPids(processGroupId)) if (pid !== processGroupId) terminal.descendantPids.add(pid);
+	for (const pid of await listProcessGroupPids(processGroupId, terminal.processHelperTimeoutMs)) if (pid !== processGroupId) terminal.descendantPids.add(pid);
 }
-async function listProcessGroupPids(processGroupId) {
+async function listProcessGroupPids(processGroupId, timeoutMs) {
 	let output;
 	try {
-		output = await runProcessGroupListCommand();
+		output = await runProcessGroupListCommand(timeoutMs);
 	} catch {
 		return [];
 	}
@@ -3779,66 +3789,18 @@ async function listProcessGroupPids(processGroupId) {
 	}
 	return pids;
 }
-async function runProcessGroupListCommand() {
-	return await new Promise((resolve, reject) => {
-		const child = spawn("ps", ["-eo", "pid=,pgid="], { stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		] });
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`ps exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
-	});
-}
-async function runWindowsProcessListCommand() {
-	return await new Promise((resolve, reject) => {
-		const child = spawn("powershell.exe", [
-			"-NoProfile",
-			"-NonInteractive",
-			"-Command",
-			["Get-CimInstance Win32_Process |", "ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"].join(" ")
-		], {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true
-		});
-		let stdout = "";
-		let stderr = "";
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", reject);
-		child.once("close", (code, signal) => {
-			if (code === 0) {
-				resolve(stdout);
-				return;
-			}
-			reject(/* @__PURE__ */ new Error(`powershell process list exited with code ${code ?? "null"} signal ${signal ?? "null"}: ${stderr}`));
-		});
+async function runProcessGroupListCommand(timeoutMs) {
+	return await runTimedExecFile("ps", ["-eo", "pid=,pgid="], { timeoutMs });
+}
+async function runWindowsProcessListCommand(timeoutMs) {
+	return await runTimedExecFile("powershell.exe", [
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		["Get-CimInstance Win32_Process |", "ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"].join(" ")
+	], {
+		timeoutMs,
+		windowsHide: true
 	});
 }
 async function killWindowsProcessTree(pid, signal) {
@@ -3898,6 +3860,14 @@ const STARTUP_STDERR_MAX_CHARS = 8192;
 const DEVIN_COMPATIBILITY_CLIENT_CAPABILITIES_META = Object.freeze({ "cognition.ai/requestDiagnostics": true });
 const DEVIN_COMPATIBILITY_CLIENT_NAME = "windsurf";
 const DEFAULT_DEVIN_COMPATIBILITY_CLIENT_VERSION = "1.110.1";
+const ELICITATION_CANCEL_MESSAGES = {
+	inactive: "elicitation owner is no longer active",
+	unavailable: "elicitation handler is unavailable",
+	unsupported: "elicitation mode is not supported",
+	mismatchedSession: "elicitation session is not active",
+	cancelled: "elicitation request was cancelled",
+	requestScoped: "request-scoped elicitation has no owner"
+};
 function resolveClientInfo(devinAcp) {
 	if (!devinAcp) return {
 		name: "acpx",
@@ -3908,13 +3878,88 @@ function resolveClientInfo(devinAcp) {
 		version: process.env.ACPX_DEVIN_WINDSURF_VERSION ?? DEFAULT_DEVIN_COMPATIBILITY_CLIENT_VERSION
 	};
 }
+function normalizeElicitationModes(modes) {
+	return [...new Set((modes ?? []).filter((mode) => mode === "form" || mode === "url"))];
+}
+function cancelledElicitationResponse(message) {
+	return {
+		action: "cancel",
+		_meta: { message }
+	};
+}
+function isKnownElicitationResponse(response) {
+	if (!response || typeof response !== "object") return false;
+	const action = response.action;
+	return action === "accept" || action === "decline" || action === "cancel";
+}
+function elicitationSessionId(request) {
+	const value = request.sessionId;
+	return typeof value === "string" ? value : void 0;
+}
+function elicitationRequestScopeId(request) {
+	const value = request.requestId;
+	return value === null || typeof value === "string" || typeof value === "number" ? value : void 0;
+}
+function waitForAbort(signal) {
+	if (signal.aborted) return Promise.resolve({ kind: "aborted" });
+	return new Promise((resolve) => {
+		signal.addEventListener("abort", () => resolve({ kind: "aborted" }), { once: true });
+	});
+}
+function isExtensionNotification(message) {
+	if (!("method" in message) || "id" in message || typeof message.method !== "string") return false;
+	return message.method !== methods.client.session.update && message.method !== methods.client.elicitation.complete && message.method !== methods.protocol.cancelRequest;
+}
+function elicitationRequestId(message) {
+	if (!("method" in message) || message.method !== methods.client.elicitation.create || !("id" in message)) return;
+	return message.id;
+}
+function responseId(message) {
+	if (!("id" in message) || "method" in message) return;
+	return message.id;
+}
+function promptRequestOwner(message) {
+	if (!("method" in message) || message.method !== methods.agent.session.prompt || !("id" in message)) return;
+	const sessionId = message.params?.sessionId;
+	return typeof sessionId === "string" ? {
+		requestId: message.id,
+		sessionId
+	} : void 0;
+}
+function createAgentConnectionFacade(connection) {
+	const agent = connection.agent;
+	return {
+		signal: connection.signal,
+		close: (error) => connection.close(error),
+		initialize: async (params) => await agent.request(methods.agent.initialize, params),
+		authenticate: async (params) => {
+			await agent.request(methods.agent.authenticate, params);
+		},
+		newSession: async (params) => await agent.request(methods.agent.session.new, params),
+		loadSession: async (params) => await agent.request(methods.agent.session.load, params),
+		resumeSession: async (params) => await agent.request(methods.agent.session.resume, params),
+		prompt: async (params) => await agent.request(methods.agent.session.prompt, params),
+		setSessionMode: async (params) => await agent.request(methods.agent.session.setMode, params),
+		setSessionConfigOption: async (params) => await agent.request(methods.agent.session.setConfigOption, params),
+		extMethod: async (method, params) => await agent.request(method, params),
+		cancel: async (params) => await agent.notify(methods.agent.session.cancel, params),
+		closeSession: async (params) => {
+			await agent.request(methods.agent.session.close, params);
+		},
+		listSessions: async (params) => await agent.request(methods.agent.session.list, params)
+	};
+}
 function resolveClientCapabilities(params) {
 	const baseCapabilities = {
 		fs: {
 			readTextFile: params.fs,
 			writeTextFile: params.fs
 		},
-		terminal: params.terminal
+		terminal: params.terminal,
+		...params.elicitationModes.length > 0 ? { elicitation: {
+			...params.elicitationModes.includes("form") ? { form: {} } : {},
+			...params.elicitationModes.includes("url") ? { url: {} } : {}
+		} } : {}
 	};
 	if (!params.devinAcp) return baseCapabilities;
 	return {
@@ -3922,9 +3967,6 @@ function resolveClientCapabilities(params) {
 		_meta: DEVIN_COMPATIBILITY_CLIENT_CAPABILITIES_META
 	};
 }
-function isDevinRequestDiagnosticsMethod(method) {
-	return method === "_cognition.ai/request_diagnostics";
-}
 function hasResponseField(response, field) {
 	return !!response && typeof response === "object" && field in response;
 }
@@ -3945,6 +3987,15 @@ function toReconnectedSessionResult(response) {
 		legacyModelMetadataPresent: hasResponseField(response, "models")
 	};
 }
+function snapshotPermissionPolicy(policy) {
+	if (!policy) return;
+	return {
+		...policy.autoApprove ? { autoApprove: [...policy.autoApprove] } : {},
+		...policy.autoDeny ? { autoDeny: [...policy.autoDeny] } : {},
+		...policy.escalate ? { escalate: [...policy.escalate] } : {},
+		...policy.defaultAction ? { defaultAction: policy.defaultAction } : {}
+	};
+}
 function childProcessIsRunning(agent) {
 	if (!agent) return false;
 	return agent.exitCode == null && agent.signalCode == null && !agent.killed;
@@ -4037,6 +4088,7 @@ var AcpClient = class {
 	suppressSessionUpdates = false;
 	suppressReplaySessionUpdateMessages = false;
 	activePrompt;
+	pendingPromptOwners = [];
 	cancellingSessionIds = /* @__PURE__ */ new Set();
 	permissionAbortControllers = /* @__PURE__ */ new Map();
 	closing = false;
@@ -4051,7 +4103,9 @@ var AcpClient = class {
 		this.options = {
 			...options,
 			cwd: asAbsoluteCwd(options.cwd),
-			authPolicy: options.authPolicy ?? "skip"
+			authPolicy: options.authPolicy ?? "skip",
+			permissionPolicy: snapshotPermissionPolicy(options.permissionPolicy),
+			elicitationModes: normalizeElicitationModes(options.elicitationModes)
 		};
 		this.eventHandlers = {
 			onAcpMessage: this.options.onAcpMessage,
@@ -4118,7 +4172,7 @@ var AcpClient = class {
 		const shouldRefreshPermissionPolicy = options.permissionMode !== void 0 || options.nonInteractivePermissions !== void 0;
 		if (options.permissionMode) this.options.permissionMode = options.permissionMode;
 		if (options.nonInteractivePermissions !== void 0) this.options.nonInteractivePermissions = options.nonInteractivePermissions;
-		if (Object.prototype.hasOwnProperty.call(options, "permissionPolicy")) this.options.permissionPolicy = options.permissionPolicy;
+		if (Object.prototype.hasOwnProperty.call(options, "permissionPolicy")) this.options.permissionPolicy = snapshotPermissionPolicy(options.permissionPolicy);
 		this.updateClientCapabilityPreferences(options);
 		this.refreshRuntimePermissionPolicy(shouldRefreshPermissionPolicy);
 		if (options.suppressSdkConsoleErrors !== void 0) this.options.suppressSdkConsoleErrors = options.suppressSdkConsoleErrors;
@@ -4141,6 +4195,15 @@ var AcpClient = class {
 		if (sessionId == null) return true;
 		return this.activePrompt.sessionId === sessionId;
 	}
+	hasUnresolvedPrompt() {
+		return this.activePrompt !== void 0;
+	}
+	endPromptElicitation(sessionId) {
+		const active = this.activePrompt;
+		if (!active || active.sessionId !== sessionId) return;
+		active.elicitationHandler = void 0;
+		active.elicitationController.abort();
+	}
 	async start() {
 		if (this.connection && this.agent && isChildProcessRunning(this.agent)) return;
 		if (this.connection || this.agent) await this.close();
@@ -4228,42 +4291,31 @@ var AcpClient = class {
 		return requireAgentStdio(spawnedChild);
 	}
 	createConnection(stream, launch) {
-		return new ClientSideConnection(() => ({
-			sessionUpdate: async (params) => {
-				await this.handleSessionUpdate(params);
-			},
-			requestPermission: async (params) => {
-				return this.handlePermissionRequest(params);
-			},
-			extMethod: async (method) => {
-				if (launch.devinAcp && isDevinRequestDiagnosticsMethod(method)) return {};
-				const error = RequestError.methodNotFound(method);
-				if (!this.options.suppressSdkConsoleErrors) console.error(error.message);
-				throw error;
-			},
-			readTextFile: async (params) => {
-				return this.handleReadTextFile(params);
-			},
-			writeTextFile: async (params) => {
-				return this.handleWriteTextFile(params);
-			},
-			createTerminal: async (params) => {
-				return this.handleCreateTerminal(params);
-			},
-			terminalOutput: async (params) => {
-				return this.handleTerminalOutput(params);
-			},
-			waitForTerminalExit: async (params) => {
-				return this.handleWaitForTerminalExit(params);
-			},
-			killTerminal: async (params) => {
-				return this.handleKillTerminal(params);
-			},
-			releaseTerminal: async (params) => {
-				return this.handleReleaseTerminal(params);
-			},
-			extNotification: async () => {}
-		}), stream);
+		const app = client({ name: "acpx" }).onNotification(methods.client.session.update, async ({ params }) => {
+			await this.handleSessionUpdate(params);
+		}).onNotification(methods.client.elicitation.complete, async () => {}).onRequest(methods.client.session.requestPermission, async ({ params }) => {
+			return await this.handlePermissionRequest(params);
+		}).onRequest(methods.client.elicitation.create, async ({ params, requestId, signal }) => {
+			return await this.handleElicitationRequest(params, requestId, signal);
+		}).onRequest(methods.client.fs.readTextFile, async ({ params }) => {
+			return await this.handleReadTextFile(params);
+		}).onRequest(methods.client.fs.writeTextFile, async ({ params }) => {
+			return await this.handleWriteTextFile(params);
+		}).onRequest(methods.client.terminal.create, async ({ params }) => {
+			return await this.handleCreateTerminal(params);
+		}).onRequest(methods.client.terminal.output, async ({ params }) => {
+			return await this.handleTerminalOutput(params);
+		}).onRequest(methods.client.terminal.waitForExit, async ({ params }) => {
+			return await this.handleWaitForTerminalExit(params);
+		}).onRequest(methods.client.terminal.kill, async ({ params }) => {
+			return await this.handleKillTerminal(params);
+		}).onRequest(methods.client.terminal.release, async ({ params }) => {
+			return await this.handleReleaseTerminal(params);
+		});
+		if (launch.devinAcp) app.onRequest("_cognition.ai/request_diagnostics", (params) => {
+			return params && typeof params === "object" && !Array.isArray(params) ? params : {};
+		}, async () => ({}));
+		return createAgentConnectionFacade(app.connect(stream));
 	}
 	async initializeAgentConnection(params) {
 		try {
@@ -4274,6 +4326,7 @@ var AcpClient = class {
 			this.initResult = initResult;
 			this.log(`initialized protocol version ${initResult.protocolVersion}`);
 		} catch (error) {
+			params.connection.close?.(error);
 			await this.handleInitializeFailure(params, error);
 		}
 	}
@@ -4283,7 +4336,8 @@ var AcpClient = class {
 			clientCapabilities: resolveClientCapabilities({
 				devinAcp: launch.devinAcp,
 				fs: this.options.fs !== false,
-				terminal: this.options.terminal !== false
+				terminal: this.options.terminal !== false,
+				elicitationModes: this.options.elicitationModes ?? []
 			}),
 			clientInfo: resolveClientInfo(launch.devinAcp)
 		});
@@ -4306,9 +4360,24 @@ var AcpClient = class {
 	createTappedStream(base) {
 		const onAcpMessage = () => this.eventHandlers.onAcpMessage;
 		const onAcpOutputMessage = () => this.eventHandlers.onAcpOutputMessage;
+		const elicitationRequestIds = /* @__PURE__ */ new Set();
+		const bindPromptOwner = (owner) => {
+			this.bindPromptOwner(owner);
+		};
 		const shouldSuppressInboundReplaySessionUpdate = (message) => {
 			return this.suppressReplaySessionUpdateMessages && isSessionUpdateNotification(message);
 		};
+		const observeInbound = (message) => {
+			const requestId = elicitationRequestId(message);
+			if (requestId !== void 0) {
+				elicitationRequestIds.add(requestId);
+				return;
+			}
+			if (!shouldSuppressInboundReplaySessionUpdate(message)) {
+				onAcpOutputMessage()?.("inbound", message);
+				onAcpMessage()?.("inbound", message);
+			}
+		};
 		return {
 			readable: new ReadableStream({ async start(controller) {
 				const reader = base.readable.getReader();
@@ -4317,10 +4386,8 @@ var AcpClient = class {
 						const { value, done } = await reader.read();
 						if (done) break;
 						if (!value) continue;
-						if (!shouldSuppressInboundReplaySessionUpdate(value)) {
-							onAcpOutputMessage()?.("inbound", value);
-							onAcpMessage()?.("inbound", value);
-						}
+						observeInbound(value);
+						if (isExtensionNotification(value)) continue;
 						controller.enqueue(value);
 					}
 				} finally {
@@ -4329,8 +4396,13 @@ var AcpClient = class {
 				}
 			} }),
 			writable: new WritableStream({ async write(message) {
-				onAcpOutputMessage()?.("outbound", message);
-				onAcpMessage()?.("outbound", message);
+				const promptOwner = promptRequestOwner(message);
+				if (promptOwner) bindPromptOwner(promptOwner);
+				const id = responseId(message);
+				if (!(id !== void 0 && elicitationRequestIds.delete(id))) {
+					onAcpOutputMessage()?.("outbound", message);
+					onAcpMessage()?.("outbound", message);
+				}
 				const writer = base.writable.getWriter();
 				try {
 					await writer.write(message);
@@ -4426,24 +4498,23 @@ var AcpClient = class {
 		this.suppressSessionUpdates = previous.suppressSessionUpdates;
 		this.suppressReplaySessionUpdateMessages = previous.suppressReplaySessionUpdateMessages;
 	}
-	async prompt(sessionId, prompt) {
+	async prompt(sessionId, prompt, onRequestStarted, onElicitation) {
 		const connection = this.getConnection();
 		const normalizedPrompt = this.normalizePromptForAgent(prompt);
 		const restoreConsoleError = this.options.suppressSdkConsoleErrors ? installSdkConsoleErrorSuppression() : void 0;
+		const activePrompt = this.beginActivePrompt(sessionId, onElicitation);
 		let promptPromise;
 		try {
 			promptPromise = this.runConnectionRequest(() => connection.prompt({
 				sessionId,
 				prompt: normalizedPrompt
-			}));
+			}), onRequestStarted, () => !connection.signal?.aborted);
 		} catch (error) {
+			this.clearActivePrompt(activePrompt);
 			restoreConsoleError?.();
 			throw error;
 		}
-		this.activePrompt = {
-			sessionId,
-			promise: promptPromise
-		};
+		activePrompt.promise = promptPromise;
 		try {
 			return this.returnPromptResponseOrPermissionFailure(sessionId, await promptPromise);
 		} catch (error) {
@@ -4451,12 +4522,37 @@ var AcpClient = class {
 			throw error;
 		} finally {
 			restoreConsoleError?.();
-			if (this.activePrompt?.promise === promptPromise) this.activePrompt = void 0;
+			this.clearActivePrompt(activePrompt);
 			this.cancellingSessionIds.delete(sessionId);
 			this.abortAndDropPermissionSignal(sessionId);
 			this.promptPermissionFailures.delete(sessionId);
 		}
 	}
+	beginActivePrompt(sessionId, elicitationHandler) {
+		const previous = this.activePrompt;
+		this.cancellingSessionIds.delete(sessionId);
+		const active = {
+			sessionId,
+			elicitationHandler,
+			elicitationController: new AbortController()
+		};
+		this.activePrompt = active;
+		this.pendingPromptOwners.push(active);
+		previous?.elicitationController?.abort();
+		return active;
+	}
+	bindPromptOwner(owner) {
+		const active = this.pendingPromptOwners.find((candidate) => {
+			return candidate.requestId === void 0 && candidate.sessionId === owner.sessionId;
+		});
+		if (active) active.requestId = owner.requestId;
+	}
+	clearActivePrompt(active) {
+		if (this.activePrompt === active) this.activePrompt = void 0;
+		const pendingIndex = this.pendingPromptOwners.indexOf(active);
+		if (pendingIndex >= 0) this.pendingPromptOwners.splice(pendingIndex, 1);
+		active.elicitationController.abort();
+	}
 	normalizePromptForAgent(prompt) {
 		const normalizedPrompt = typeof prompt === "string" ? textPrompt(prompt) : prompt;
 		const unsupportedPromptContent = getUnsupportedPromptContentMessage(normalizedPrompt, this.initResult?.agentCapabilities);
@@ -4569,12 +4665,18 @@ var AcpClient = class {
 	}
 	async cancel(sessionId) {
 		const connection = this.getConnection();
-		this.cancellingSessionIds.add(sessionId);
+		const active = this.activePrompt;
+		if (active?.sessionId === sessionId) {
+			this.cancellingSessionIds.add(sessionId);
+			active.elicitationController?.abort();
+		} else this.cancellingSessionIds.delete(sessionId);
 		this.abortAndDropPermissionSignal(sessionId);
 		await this.runConnectionRequest(() => connection.cancel({ sessionId }));
 	}
 	async closeSession(sessionId) {
 		const connection = this.getConnection();
+		this.cancellingSessionIds.add(sessionId);
+		if (this.activePrompt?.sessionId === sessionId) this.activePrompt.elicitationController?.abort();
 		await this.runConnectionRequest(() => connection.closeSession({ sessionId }));
 		if (this.loadedSessionId === sessionId) this.loadedSessionId = void 0;
 		this.modelConfigIds.delete(sessionId);
@@ -4600,21 +4702,25 @@ var AcpClient = class {
 			this.log(`failed to send session/cancel: ${message}`);
 		}
 		if (waitMs <= 0) return;
+		const activePromise = active.promise;
+		if (!activePromise) return;
 		let timer;
 		const timeoutPromise = new Promise((resolve) => {
 			timer = setTimeout(resolve, waitMs);
 		});
 		try {
-			return await Promise.race([active.promise.then((response) => response, () => void 0), timeoutPromise]);
+			return await Promise.race([activePromise.then((response) => response, () => void 0), timeoutPromise]);
 		} finally {
 			if (timer) clearTimeout(timer);
 		}
 	}
 	async close() {
 		this.closing = true;
+		this.abortActiveElicitation();
 		await this.terminalManager.shutdown();
 		const agent = this.agent;
 		if (agent) await this.terminateAgentProcess(agent);
+		this.closeConnection();
 		if (this.pendingConnectionRequests.size > 0) this.rejectPendingConnectionRequests(this.lastAgentExit ? new AgentDisconnectedError(this.lastAgentExit.reason, this.lastAgentExit.exitCode, this.lastAgentExit.signal, { outputAlreadyEmitted: Boolean(this.activePrompt) }) : new AgentDisconnectedError("connection_close", null, null, { outputAlreadyEmitted: Boolean(this.activePrompt) }));
 		this.sessionUpdateChain = Promise.resolve();
 		this.observedSessionUpdates = 0;
@@ -4622,6 +4728,7 @@ var AcpClient = class {
 		this.suppressSessionUpdates = false;
 		this.suppressReplaySessionUpdateMessages = false;
 		this.activePrompt = void 0;
+		this.pendingPromptOwners.length = 0;
 		this.cancellingSessionIds.clear();
 		for (const controller of this.permissionAbortControllers.values()) controller.abort();
 		this.permissionAbortControllers.clear();
@@ -4633,6 +4740,12 @@ var AcpClient = class {
 		this.connection = void 0;
 		this.agent = void 0;
 	}
+	abortActiveElicitation() {
+		this.activePrompt?.elicitationController?.abort();
+	}
+	closeConnection() {
+		this.connection?.close?.();
+	}
 	async terminateAgentProcess(child) {
 		const stdinCloseGraceMs = resolveAgentCloseAfterStdinEndMs(this.options.agentCommand);
 		this.endAgentStdin(child);
@@ -4791,12 +4904,12 @@ var AcpClient = class {
 		const { command, args } = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
 		return command.replace(/\\/g, "/").split("/").pop()?.replace(/\.(cmd|exe|ps1)$/iu, "").toLowerCase() === "grok" && args[0] === "agent" && args[1] === "stdio";
 	}
-	async authenticateIfRequired(connection, methods) {
-		if (methods.length === 0) return;
-		const selected = this.selectAuthMethod(methods);
+	async authenticateIfRequired(connection, authMethods) {
+		if (authMethods.length === 0) return;
+		const selected = this.selectAuthMethod(authMethods);
 		if (!selected) {
-			if (this.options.authPolicy === "fail") throw new AuthPolicyError(`agent advertised auth methods [${methods.map((m) => m.id).join(", ")}] but no matching credentials found`);
-			this.log(`agent advertised auth methods [${methods.map((m) => m.id).join(", ")}] but no matching credentials found — skipping (agent may handle auth internally)`);
+			if (this.options.authPolicy === "fail") throw new AuthPolicyError(`agent advertised auth methods [${authMethods.map((m) => m.id).join(", ")}] but no matching credentials found`);
+			this.log(`agent advertised auth methods [${authMethods.map((m) => m.id).join(", ")}] but no matching credentials found — skipping (agent may handle auth internally)`);
 			return;
 		}
 		await connection.authenticate({ methodId: selected.methodId });
@@ -4813,6 +4926,50 @@ var AcpClient = class {
 		}
 		return response;
 	}
+	async handleElicitationRequest(request, requestId, requestSignal) {
+		const resolved = this.resolveElicitationOwner(request);
+		if ("response" in resolved) return resolved.response;
+		const { active, handler } = resolved.owner;
+		const signal = AbortSignal.any([requestSignal, active.elicitationController.signal]);
+		const handlerAttempt = Promise.resolve().then(async () => await handler(request, {
+			requestId,
+			signal
+		})).then((response) => ({
+			kind: "response",
+			response
+		}), (error) => ({
+			kind: "error",
+			error
+		}));
+		const outcome = await Promise.race([handlerAttempt, waitForAbort(signal)]);
+		if (this.activePrompt !== active) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.inactive);
+		if (outcome.kind === "aborted" || signal.aborted) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.cancelled);
+		if (outcome.kind === "error" || !isKnownElicitationResponse(outcome.response)) return cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unavailable);
+		return outcome.response;
+	}
+	resolveElicitationOwner(request) {
+		if (!this.options.elicitationModes?.includes(request.mode)) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unsupported) };
+		const active = this.activePrompt;
+		if (!active) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.inactive) };
+		const scope = this.resolveElicitationScope(request, active);
+		if ("response" in scope) return scope;
+		if (this.isElicitationSessionCancelling(scope.sessionId)) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.cancelled) };
+		if (!active.elicitationHandler) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.unavailable) };
+		return { owner: {
+			active,
+			handler: active.elicitationHandler
+		} };
+	}
+	resolveElicitationScope(request, active) {
+		const sessionId = elicitationSessionId(request);
+		if (sessionId) return sessionId === active.sessionId ? { sessionId } : { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.mismatchedSession) };
+		const requestScopeId = elicitationRequestScopeId(request);
+		if (requestScopeId === void 0 || requestScopeId !== active.requestId) return { response: cancelledElicitationResponse(ELICITATION_CANCEL_MESSAGES.requestScoped) };
+		return { sessionId: active.sessionId };
+	}
+	isElicitationSessionCancelling(sessionId) {
+		return this.closing || this.cancellingSessionIds.has(sessionId);
+	}
 	async tryHandlePermissionRequestWithHost(params) {
 		if (!this.options.onPermissionRequest) return;
 		const signal = this.cancellationSignalForSession(params.sessionId);
@@ -4898,7 +5055,7 @@ var AcpClient = class {
 		if (error) this.promptPermissionFailures.delete(sessionId);
 		return error;
 	}
-	async runConnectionRequest(run) {
+	async runConnectionRequest(run, onRequestStarted, canStartRequest = () => true) {
 		return await new Promise((resolve, reject) => {
 			const pending = {
 				settled: false,
@@ -4911,7 +5068,20 @@ var AcpClient = class {
 				cb();
 			};
 			this.pendingConnectionRequests.add(pending);
-			Promise.resolve().then(run).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+			Promise.resolve().then(async () => {
+				if (pending.settled) return { started: false };
+				const requestCanStart = canStartRequest();
+				const request = run();
+				if (requestCanStart) try {
+					Promise.resolve(onRequestStarted?.()).catch(() => {});
+				} catch {}
+				return {
+					started: true,
+					value: await request
+				};
+			}).then((outcome) => {
+				if (outcome.started) finish(() => resolve(outcome.value));
+			}, (error) => finish(() => reject(error)));
 		});
 	}
 	rejectPendingConnectionRequests(error) {
@@ -5712,18 +5882,6 @@ function trimRuntimeToolResult(result) {
 	if (typeof result.output === "string") result.output = trimRuntimeText(result.output, MAX_RUNTIME_TOOL_IO_CHARS);
 }
 //#endregion
-//#region src/session/config-options.ts
-function applyConfigOptionsToState(state, configOptions) {
-	const acpxState = cloneSessionAcpxState(state) ?? {};
-	applyConfigOptionsModelState(acpxState, configOptions);
-	return acpxState;
-}
-function applyConfigOptionsToRecord(record, result) {
-	const configOptions = result?.configOptions;
-	if (!configOptions) return;
-	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
-}
-//#endregion
 //#region src/session/mode-preference.ts
 function ensureAcpxState(state) {
 	return state ?? {};
@@ -5756,17 +5914,6 @@ function setDesiredModeId(record, modeId) {
 	else delete acpx.desired_mode_id;
 	record.acpx = acpx;
 }
-function setDesiredConfigOption(record, configId, value) {
-	const normalizedConfigId = normalizeModeId(configId);
-	if (!normalizedConfigId || normalizedConfigId === "mode" || normalizedConfigId === "model") return;
-	const acpx = ensureAcpxState(record.acpx);
-	const desired = { ...acpx.desired_config_options };
-	if (typeof value === "string") desired[normalizedConfigId] = value;
-	else delete desired[normalizedConfigId];
-	if (Object.keys(desired).length > 0) acpx.desired_config_options = desired;
-	else delete acpx.desired_config_options;
-	record.acpx = acpx;
-}
 function clearDesiredConfigOption(state, configId) {
 	const normalizedConfigId = normalizeModeId(configId);
 	if (!normalizedConfigId || !state.desired_config_options) return;
@@ -5778,20 +5925,6 @@ function clearDesiredConfigOption(state, configId) {
 function getDesiredModelId(state) {
 	return normalizeModelId(state?.session_options?.model);
 }
-function hasStoredSessionOptions(options) {
-	return typeof options.model === "string" || Array.isArray(options.allowed_tools) || typeof options.max_turns === "number" || options.system_prompt !== void 0 || options.env !== void 0;
-}
-function setDesiredModelId(record, modelId, modelConfigId) {
-	const acpx = ensureAcpxState(record.acpx);
-	const normalized = normalizeModelId(modelId);
-	const sessionOptions = { ...acpx.session_options };
-	if (normalized) sessionOptions.model = normalized;
-	else delete sessionOptions.model;
-	if (hasStoredSessionOptions(sessionOptions)) acpx.session_options = sessionOptions;
-	else delete acpx.session_options;
-	clearDesiredConfigOption(acpx, modelConfigId ?? modelStateFromConfigOptions(acpx.config_options)?.configId);
-	record.acpx = acpx;
-}
 function setCurrentModelId(record, modelId) {
 	const acpx = ensureAcpxState(record.acpx);
 	const normalized = normalizeModelId(modelId);
@@ -5828,6 +5961,50 @@ async function applyRequestedModelIfAdvertised(params) {
 	};
 }
 //#endregion
+//#region src/session/config-options.ts
+function applyConfigOptionsToState(state, configOptions) {
+	const acpxState = cloneSessionAcpxState(state) ?? {};
+	applyConfigOptionsModelState(acpxState, configOptions);
+	return acpxState;
+}
+function applyConfigOptionsToRecord(record, result) {
+	const configOptions = result?.configOptions;
+	if (!configOptions) return;
+	record.acpx = applyConfigOptionsToState(record.acpx, configOptions);
+}
+function applyAcceptedConfigOptions(state, response) {
+	const next = cloneSessionAcpxState(state) ?? {};
+	if (!response) return next;
+	applyConfigOptionsModelState(next, response.configOptions);
+	if (!next.desired_config_options) return next;
+	const desired = {};
+	for (const option of response.configOptions) if (typeof option.currentValue === "string" && Object.hasOwn(next.desired_config_options, option.id)) desired[option.id] = option.currentValue;
+	if (Object.keys(desired).length > 0) next.desired_config_options = desired;
+	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) ?? {};
+	if (configId === "mode") next.desired_mode_id = value;
+	else next.desired_config_options = {
+		...next.desired_config_options,
+		[configId]: value
+	};
+	return applyAcceptedConfigOptions(next, response);
+}
+//#endregion
 //#region src/runtime/engine/reconnect.ts
 function isProcessAlive(pid) {
 	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
@@ -5872,8 +6049,11 @@ async function replayDesiredMode(params) {
 		});
 	}
 }
+function canReplayModel(desiredModelId, models, createdFreshSession) {
+	return Boolean(desiredModelId) && (createdFreshSession || models !== void 0);
+}
 async function replayDesiredModel(params) {
-	if (!params.desiredModelId) return { replayed: false };
+	if (!canReplayModel(params.desiredModelId, params.models, params.createdFreshSession)) return { replayed: false };
 	try {
 		emitModelSupportWarning(assertRequestedModelSupported({
 			requestedModel: params.desiredModelId,
@@ -5881,21 +6061,21 @@ async function replayDesiredModel(params) {
 			agentCommand: params.record.agentCommand,
 			context: "replay"
 		}), params.suppressWarnings);
-		if (!params.models || params.models.currentModelId === params.desiredModelId) return { replayed: false };
+		if (!params.models) return { replayed: false };
 		const response = await withTimeout(params.client.setSessionModel(params.sessionId, params.desiredModelId, params.models), params.timeoutMs);
-		applyConfigOptionsToRecord(params.record, response);
+		params.record.acpx = applyModelSelection(params.record.acpx, params.desiredModelId, response);
 		const models = response ? modelStateFromConfigOptions(response.configOptions) : {
 			...params.models,
 			currentModelId: params.desiredModelId
 		};
-		if (params.verbose) process.stderr.write(`[acpx] replayed desired model ${params.desiredModelId} on fresh ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
+		if (params.verbose) process.stderr.write(`[acpx] replayed desired model ${params.desiredModelId} on ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
 		return {
 			replayed: true,
 			models,
-			configOptionsPresent: response !== void 0
+			configOptions: response?.configOptions
 		};
 	} catch (error) {
-		throw new SessionModelReplayError(`Failed to replay saved session model ${params.desiredModelId} on fresh ACP session ${params.sessionId}: ${formatErrorMessage(error)}`, {
+		throw new SessionModelReplayError(`Failed to replay saved session model ${params.desiredModelId} on ACP session ${params.sessionId}: ${formatErrorMessage(error)}`, {
 			cause: error instanceof Error ? error : void 0,
 			retryable: true
 		});
@@ -5906,19 +6086,25 @@ function emitModelSupportWarning(warning, suppressWarnings) {
 }
 async function replayDesiredConfigOptions(params) {
 	let result = { replayed: false };
-	for (const [configId, value] of Object.entries(params.desiredConfigOptions)) try {
-		const response = await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value), params.timeoutMs);
-		applyConfigOptionsToRecord(params.record, response);
-		result = {
-			replayed: true,
-			models: modelStateFromConfigOptions(response.configOptions)
-		};
-		if (params.verbose) process.stderr.write(`[acpx] replayed desired config option ${configId} on fresh ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
-	} catch (error) {
-		throw new SessionConfigOptionReplayError(`Failed to replay saved session config option ${configId} on fresh ACP session ${params.sessionId}: ${formatErrorMessage(error)}`, {
-			cause: error instanceof Error ? error : void 0,
-			retryable: true
-		});
+	let acceptedConfigOptions = params.acceptedConfigOptions;
+	const replacingKey = resolveReplacingConfigOptionId(params.replacingConfigOption, params.record);
+	for (const [configId, value] of Object.entries(params.desiredConfigOptions)) {
+		if (configId === replacingKey || acceptedConfigOptions && !acceptsSavedConfigValue(acceptedConfigOptions.find((option) => option.id === configId), value)) continue;
+		try {
+			const response = await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value), params.timeoutMs);
+			params.record.acpx = applyConfigOptionSelection(params.record.acpx, configId, value, response);
+			acceptedConfigOptions = response.configOptions;
+			result = {
+				replayed: true,
+				models: modelStateFromConfigOptions(response.configOptions)
+			};
+			if (params.verbose) process.stderr.write(`[acpx] replayed desired config option ${configId} on ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
+		} catch (error) {
+			throw new SessionConfigOptionReplayError(`Failed to replay saved session config option ${configId} on ACP session ${params.sessionId}: ${formatErrorMessage(error)}`, {
+				cause: error instanceof Error ? error : void 0,
+				retryable: true
+			});
+		}
 	}
 	return result;
 }
@@ -5965,10 +6151,12 @@ async function connectAndLoadSession(options) {
 	createdFreshSession = loadState.createdFreshSession;
 	pendingAgentSessionId = loadState.pendingAgentSessionId;
 	sessionModels = loadState.sessionModels;
-	const preferenceReplay = await replayFreshSessionPreferences({
+	const preferenceReplay = await replaySessionPreferences({
 		client,
 		record,
 		createdFreshSession,
+		reusingLoadedSession,
+		replacingConfigOption: options.replacingConfigOption,
 		sessionId,
 		pendingAgentSessionId,
 		originalSessionId,
@@ -5999,7 +6187,7 @@ function preserveLegacyModels(models) {
 	return models && !models.configId ? models : void 0;
 }
 function resolveConfigOptionsPresenceAfterReplay(replay, initiallyPresent) {
-	return initiallyPresent || replay.configReplay.replayed || replay.modelReplay.replayed && replay.modelReplay.configOptionsPresent;
+	return initiallyPresent || replay.configReplay.replayed || replay.modelReplay.configOptions !== void 0;
 }
 function applyReconnectedModelState(record, sessionModels, configOptionsPresent, legacyModelMetadataPresent, createdFreshSession) {
 	clearOmittedFreshSessionConfigOptions(record, createdFreshSession, configOptionsPresent);
@@ -6022,18 +6210,30 @@ function logReconnectAttempt(record, storedProcessAlive, shouldReconnect, verbos
 	}
 	if (shouldReconnect) process.stderr.write(`[acpx] saved session pid ${record.pid} is dead; respawning agent and attempting session reconnect\n`);
 }
-async function replayFreshSessionPreferences(params) {
-	if (!params.createdFreshSession) return {
+function replacesModel(replacingConfigOption, models, originalAcpx) {
+	const key = replacingConfigOption?.key;
+	return key !== void 0 && (key === "model" || key === models?.configId || key === advertisedModelState(originalAcpx)?.configId);
+}
+function acceptsSavedConfigValue(option, value) {
+	if (!option || option.type !== "select") return false;
+	return option.currentValue === value || option.options.some((entry) => "options" in entry ? entry.options.some((choice) => choice.value === value) : entry.value === value);
+}
+function resolveReplacingConfigOptionId(replacement, record) {
+	return replacement?.resolve?.(record) ?? replacement?.key;
+}
+async function replaySessionPreferences(params) {
+	if (params.reusingLoadedSession) return {
 		modelReplay: { replayed: false },
 		configReplay: { replayed: false }
 	};
 	let modelReplay = { replayed: false };
 	let configReplay = { replayed: false };
+	const replacingModel = replacesModel(params.replacingConfigOption, params.sessionModels, params.originalAcpx);
 	try {
 		await replayDesiredMode({
 			client: params.client,
 			sessionId: params.sessionId,
-			desiredModeId: params.desiredModeId,
+			desiredModeId: params.createdFreshSession ? params.desiredModeId : void 0,
 			previousSessionId: params.originalSessionId,
 			timeoutMs: params.timeoutMs,
 			verbose: params.verbose
@@ -6041,10 +6241,11 @@ async function replayFreshSessionPreferences(params) {
 		modelReplay = await replayDesiredModel({
 			client: params.client,
 			sessionId: params.sessionId,
-			desiredModelId: params.desiredModelId,
+			desiredModelId: replacingModel ? void 0 : params.desiredModelId,
 			previousSessionId: params.originalSessionId,
 			record: params.record,
 			models: params.sessionModels,
+			createdFreshSession: params.createdFreshSession,
 			timeoutMs: params.timeoutMs,
 			verbose: params.verbose,
 			suppressWarnings: params.suppressWarnings
@@ -6053,7 +6254,9 @@ async function replayFreshSessionPreferences(params) {
 			client: params.client,
 			record: params.record,
 			sessionId: params.sessionId,
-			desiredConfigOptions: params.desiredConfigOptions,
+			desiredConfigOptions: replacingModel ? {} : params.desiredConfigOptions,
+			acceptedConfigOptions: modelReplay.configOptions,
+			replacingConfigOption: replacingModel ? void 0 : params.replacingConfigOption,
 			previousSessionId: params.originalSessionId,
 			timeoutMs: params.timeoutMs,
 			verbose: params.verbose
@@ -6178,35 +6381,24 @@ function createActiveSessionController(params) {
 }
 async function withConnectedSession(options) {
 	const record = await options.loadRecord(options.sessionRecordId);
-	const client = options.createClient?.({
-		agentCommand: record.agentCommand,
-		agentArgv: record.agentArgv,
-		cwd: absolutePath(record.cwd),
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode ?? "approve-reads",
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		onPermissionRequest: options.onPermissionRequest,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		terminal: options.terminal,
-		verbose: options.verbose,
-		sessionOptions: sessionOptionsFromRecord(record)
-	}) ?? new AcpClient({
+	const clientOptions = {
 		agentCommand: record.agentCommand,
 		agentArgv: record.agentArgv,
 		cwd: absolutePath(record.cwd),
 		mcpServers: options.mcpServers,
 		permissionMode: options.permissionMode ?? "approve-reads",
 		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
 		onPermissionRequest: options.onPermissionRequest,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
 		fs: options.fs,
 		terminal: options.terminal,
+		elicitationModes: options.elicitationModes,
 		verbose: options.verbose,
 		sessionOptions: sessionOptionsFromRecord(record)
-	});
+	};
+	const client = options.createClient?.(clientOptions) ?? new AcpClient(clientOptions);
 	let activeSessionIdForControl = record.acpSessionId;
 	let notifiedClientAvailable = false;
 	const activeController = createActiveSessionController({
@@ -6220,6 +6412,7 @@ async function withConnectedSession(options) {
 				client,
 				record,
 				resumePolicy: options.resumePolicy,
+				replacingConfigOption: options.replacingConfigOption,
 				timeoutMs: options.timeoutMs,
 				verbose: options.verbose,
 				activeController,
@@ -6278,7 +6471,7 @@ const SESSION_REPLY_IDLE_MS = 1e3;
 const SESSION_REPLY_DRAIN_TIMEOUT_MS = 5e3;
 async function runPromptTurn(params) {
 	try {
-		const promptPromise = params.client.prompt(params.sessionId, params.prompt);
+		const promptPromise = params.client.prompt(params.sessionId, params.prompt, params.onPromptRequestStarted, params.onElicitation);
 		await params.onPromptStarted?.();
 		const response = await withTimeout(promptPromise, params.timeoutMs);
 		await params.client.waitForSessionUpdatesIdle?.({
@@ -6357,6 +6550,6 @@ var LiveSessionCheckpoint = class {
 	}
 };
 //#endregion
-export { createAtomicWriteTempPath as $, SESSION_RECORD_SCHEMA as $t, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as A, withInterrupt as At, permissionModeSatisfies as B, isRetryablePromptError as Bt, mergeSessionOptions as C, isPromptInput as Ct, applyLifecycleSnapshotToRecord as D, textPrompt as Dt, applyConversation as E, promptToDisplayText as Et, modelStateFromConfigOptions as F, resolveAgentArgv as Ft, findSessionByDirectoryWalk as G, AUTH_POLICIES as Gt, absolutePath as H, extractAcpError as Ht, normalizeAgentCommandInput as I, resolveAgentCommand as It, listSessionsForAgent as J, OUTPUT_ERROR_CODES as Jt, isoNow$2 as K, EXIT_CODES as Kt, renderArgvIdentity as L, resolveCanonicalAgentName as Lt, RequestedModelUnsupportedError as M, DEFAULT_AGENT_NAME as Mt, assertRequestedModelSupported as N, listBuiltInAgents as Nt, reconcileAgentSessionId as O, InterruptedError as Ot, isRequestedModelUnsupportedError as P, normalizeAgentName$1 as Pt, writeSessionRecord as Q, PERMISSION_POLICY_ACTIONS as Qt, splitCommandLine as R, exitCodeForOutputErrorCode as Rt, advertisedModelState as S, PromptInputValidationError as St, sessionOptionsFromRecord as T, parsePromptSource as Tt, findGitRepositoryRoot as U, isAcpResourceNotFoundError as Ut, DEFAULT_HISTORY_LIMIT as V, normalizeOutputError as Vt, findSession as W, toAcpErrorPayload as Wt, pruneSessions as X, OUTPUT_FORMATS as Xt, normalizeName as Y, OUTPUT_ERROR_ORIGINS as Yt, resolveSessionRecord as Z, PERMISSION_MODES as Zt, createSessionConversation as _, sessionEventSegmentPath as _t, applyRequestedModelIfAdvertised as a, recordPerfDuration as at, recordSessionUpdate as b, parseJsonRpcErrorMessage as bt, setCurrentModelId as c, startPerfTimer as ct, setDesiredModelId as d, normalizeRuntimeSessionId as dt, AcpxOperationalError as en, assertPersistedKeyPolicy as et, syncAdvertisedModelState as f, DEFAULT_EVENT_SEGMENT_MAX_BYTES as ft, cloneSessionConversation as g, sessionEventLockPath as gt, cloneSessionAcpxState as h, sessionEventActivePath as ht, connectAndLoadSession as i, measurePerf as it, REQUESTED_MODEL_UNSUPPORTED_REASONS as j, withTimeout as jt, AcpClient as k, TimeoutError as kt, setDesiredConfigOption as l, parseSessionRecord as lt, applyConfigOptionsToState as m, sessionBaseDir$1 as mt, runPromptTurn as n, QueueConnectionError as nn, getPerfMetricsSnapshot as nt, currentModelIdFromSetModelResponse as o, resetPerfMetrics as ot, applyConfigOptionsToRecord as p, defaultSessionEventLog as pt, listSessions as q, NON_INTERACTIVE_PERMISSION_POLICIES as qt, withConnectedSession as r, QueueProtocolError as rn, incrementPerfCounter as rt, clearDesiredConfigOption as s, setPerfGauge as st, LiveSessionCheckpoint as t, AgentSpawnError as tn, formatPerfMetric as tt, setDesiredModeId as u, serializeSessionRecordForDisk as ut, recordClientOperation as v, extractSessionUpdateNotification as vt, persistSessionOptions as w, mergePromptSourceWithText as wt, trimConversationForRuntime as x, parsePromptStopReason as xt, recordPromptSubmission as y, isAcpJsonRpcMessage as yt, getAcpxVersion as z, formatErrorMessage as zt };
+export { formatPerfMetric as $, AgentSpawnError as $t, RequestedModelUnsupportedError as A, DEFAULT_AGENT_NAME as At, absolutePath as B, extractAcpError as Bt, sessionOptionsFromRecord as C, parsePromptSource as Ct, AcpClient as D, TimeoutError as Dt, reconcileAgentSessionId as E, InterruptedError as Et, runTimedExecFile as F, resolveCanonicalAgentName as Ft, listSessions as G, NON_INTERACTIVE_PERMISSION_POLICIES as Gt, findSession as H, toAcpErrorPayload as Ht, splitCommandLine as I, exitCodeForOutputErrorCode as It, pruneSessions as J, OUTPUT_FORMATS as Jt, listSessionsForAgent as K, OUTPUT_ERROR_CODES as Kt, getAcpxVersion as L, formatErrorMessage as Lt, modelStateFromConfigOptions as M, normalizeAgentName$1 as Mt, normalizeAgentCommandInput as N, resolveAgentArgv as Nt, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as O, withInterrupt as Ot, renderArgvIdentity as P, resolveAgentCommand as Pt, assertPersistedKeyPolicy as Q, AcpxOperationalError as Qt, permissionModeSatisfies as R, isRetryablePromptError as Rt, persistSessionOptions as S, mergePromptSourceWithText as St, applyLifecycleSnapshotToRecord as T, textPrompt as Tt, findSessionByDirectoryWalk as U, AUTH_POLICIES as Ut, findGitRepositoryRoot as V, isAcpResourceNotFoundError as Vt, isoNow$2 as W, EXIT_CODES as Wt, writeSessionRecord as X, PERMISSION_POLICY_ACTIONS as Xt, resolveSessionRecord as Y, PERMISSION_MODES as Yt, createAtomicWriteTempPath as Z, SESSION_RECORD_SCHEMA as Zt, recordPromptSubmission as _, isAcpJsonRpcMessage as _t, applyConfigOptionSelection as a, setPerfGauge as at, advertisedModelState as b, PromptInputValidationError as bt, applyRequestedModelIfAdvertised as c, serializeSessionRecordForDisk as ct, setDesiredModeId as d, defaultSessionEventLog as dt, QueueConnectionError as en, getPerfMetricsSnapshot as et, syncAdvertisedModelState as f, sessionBaseDir$1 as ft, recordClientOperation as g, extractSessionUpdateNotification as gt, createSessionConversation as h, sessionEventSegmentPath as ht, connectAndLoadSession as i, resetPerfMetrics as it, isRequestedModelUnsupportedError as j, listBuiltInAgents as jt, REQUESTED_MODEL_UNSUPPORTED_REASONS as k, withTimeout as kt, currentModelIdFromSetModelResponse as l, normalizeRuntimeSessionId as lt, cloneSessionConversation as m, sessionEventLockPath as mt, runPromptTurn as n, measurePerf as nt, applyConfigOptionsToRecord as o, startPerfTimer as ot, cloneSessionAcpxState as p, sessionEventActivePath as pt, normalizeName as q, OUTPUT_ERROR_ORIGINS as qt, withConnectedSession as r, recordPerfDuration as rt, applyModelSelection as s, parseSessionRecord as st, LiveSessionCheckpoint as t, QueueProtocolError as tn, incrementPerfCounter as tt, setCurrentModelId as u, DEFAULT_EVENT_SEGMENT_MAX_BYTES as ut, recordSessionUpdate as v, parseJsonRpcErrorMessage as vt, applyConversation as w, promptToDisplayText as wt, mergeSessionOptions as x, isPromptInput as xt, trimConversationForRuntime as y, parsePromptStopReason as yt, DEFAULT_HISTORY_LIMIT as z, normalizeOutputError as zt };
 
-//# sourceMappingURL=live-checkpoint-CBecfnSH.js.map
+//# sourceMappingURL=live-checkpoint-Gw2oGjhe.js.map