acpx 0.5.3 → 0.6.1

package/dist/{prompt-turn-CXMtXBl-.js → prompt-turn-BY5SwU1F.js}

@@ -1,20 +1,21 @@
-import { B as PermissionPromptUnavailableError, C as isAcpResourceNotFoundError, F as AuthPolicyError, G as SessionNotFoundError, I as ClaudeAcpSessionCreateTimeoutError, K as SessionResolutionError, L as CopilotAcpUnsupportedError, M as AgentDisconnectedError, N as AgentSpawnError, P as AgentStartupError, R as GeminiAcpStartupTimeoutError, S as extractAcpError, U as SessionModeReplayError, W as SessionModelReplayError, g as textPrompt, i as measurePerf, j as SESSION_RECORD_SCHEMA, l as extractRuntimeSessionId, q as SessionResumeRequiredError, r as incrementPerfCounter, u as normalizeRuntimeSessionId, v as formatErrorMessage, y as isAcpQueryClosedBeforeResponseError, z as PermissionDeniedError } from "./perf-metrics-D0um6IR6.js";
+import { B as PermissionDeniedError, C as isAcpResourceNotFoundError, F as AgentStartupError, G as SessionModeReplayError, I as AuthPolicyError, J as SessionResolutionError, K as SessionModelReplayError, L as ClaudeAcpSessionCreateTimeoutError, M as SESSION_RECORD_SCHEMA, N as AgentDisconnectedError, P as AgentSpawnError, R as CopilotAcpUnsupportedError, S as extractAcpError, V as PermissionPromptUnavailableError, W as SessionConfigOptionReplayError, Y as SessionResumeRequiredError, g as textPrompt, i as measurePerf, l as extractRuntimeSessionId, q as SessionNotFoundError, r as incrementPerfCounter, u as normalizeRuntimeSessionId, v as formatErrorMessage, y as isAcpQueryClosedBeforeResponseError, z as GeminiAcpStartupTimeoutError } from "./perf-metrics-C2pXfxvR.js";
 import { r as isSessionUpdateNotification } from "./jsonrpc-DSxh2w5R.js";
 import fs, { statSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, PROTOCOL_VERSION } from "@agentclientprotocol/sdk";
 import readline from "node:readline/promises";
+import { promisify } from "node:util";
 import { randomUUID } from "node:crypto";
 //#region src/agent-registry.ts
 const ACP_ADAPTER_PACKAGE_RANGES = {
-	pi: "^0.0.22",
-	codex: "^0.11.1",
-	claude: "^0.25.0"
+	pi: "^0.0.26",
+	codex: "^0.12.0",
+	claude: "^0.31.0"
 };
 const AGENT_REGISTRY = {
 	pi: `npx pi-acp@${ACP_ADAPTER_PACKAGE_RANGES.pi}`,
@@ -278,6 +279,7 @@ const MAP_OBJECT_PATHS = new Set(["request_token_usage", "messages.Agent.tool_re
 const OPAQUE_VALUE_PATHS = new Set([
 	"agent_capabilities",
 	"messages.Agent.content.ToolUse.input",
+	"acpx.desired_config_options",
 	"acpx.config_options"
 ]);
 function isRecord(value) {
@@ -480,6 +482,12 @@ function parseAcpxState(raw) {
 	if (record.reset_on_next_ensure === true) state.reset_on_next_ensure = true;
 	if (typeof record.current_mode_id === "string") state.current_mode_id = record.current_mode_id;
 	if (typeof record.desired_mode_id === "string") state.desired_mode_id = record.desired_mode_id;
+	const desiredConfigOptions = asRecord$3(record.desired_config_options);
+	if (desiredConfigOptions) {
+		const parsed = {};
+		for (const [key, value] of Object.entries(desiredConfigOptions)) if (typeof key === "string" && typeof value === "string") parsed[key] = value;
+		if (Object.keys(parsed).length > 0) state.desired_config_options = parsed;
+	}
 	if (typeof record.current_model_id === "string") state.current_model_id = record.current_model_id;
 	if (isStringArray(record.available_models)) state.available_models = [...record.available_models];
 	if (isStringArray(record.available_commands)) state.available_commands = [...record.available_commands];
@@ -490,6 +498,12 @@ function parseAcpxState(raw) {
 		if (typeof sessionOptions.model === "string") parsedSessionOptions.model = sessionOptions.model;
 		if (isStringArray(sessionOptions.allowed_tools)) parsedSessionOptions.allowed_tools = [...sessionOptions.allowed_tools];
 		if (typeof sessionOptions.max_turns === "number" && Number.isInteger(sessionOptions.max_turns) && sessionOptions.max_turns > 0) parsedSessionOptions.max_turns = sessionOptions.max_turns;
+		const rawSystemPrompt = sessionOptions.system_prompt;
+		if (typeof rawSystemPrompt === "string" && rawSystemPrompt.length > 0) parsedSessionOptions.system_prompt = rawSystemPrompt;
+		else {
+			const appendRecord = asRecord$3(rawSystemPrompt);
+			if (appendRecord && typeof appendRecord.append === "string" && appendRecord.append.length > 0) parsedSessionOptions.system_prompt = { append: appendRecord.append };
+		}
 		if (Object.keys(parsedSessionOptions).length > 0) state.session_options = parsedSessionOptions;
 	}
 	return state;
@@ -831,6 +845,58 @@ async function findSessionByDirectoryWalk(options) {
 		if (!isWithinBoundary(walkBoundary, current)) return;
 	}
 }
+function closedAtOrLastUsedAt(record) {
+	return record.closedAt ?? record.lastUsedAt;
+}
+function isSessionStreamFile(fileName, safeId) {
+	return fileName === `${safeId}.stream.ndjson` || fileName === `${safeId}.stream.lock` || fileName.startsWith(`${safeId}.stream.`);
+}
+async function pruneSessions(options = {}) {
+	await ensureSessionDir();
+	let eligible = (await loadSessionIndexEntries()).filter((entry) => entry.closed);
+	if (options.agentCommand) eligible = eligible.filter((entry) => entry.agentCommand === options.agentCommand);
+	const cutoff = options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0);
+	const records = [];
+	for (const entry of eligible) {
+		const record = await loadRecordFromIndexEntry(entry);
+		if (record && (!cutoff || closedAtOrLastUsedAt(record) < cutoff.toISOString())) records.push(record);
+	}
+	if (options.dryRun) return {
+		pruned: records,
+		bytesFreed: 0,
+		dryRun: true
+	};
+	const sessionDir = sessionBaseDir();
+	let bytesFreed = 0;
+	let dirEntries = [];
+	if (options.includeHistory) try {
+		dirEntries = await fs$1.readdir(sessionDir);
+	} catch {}
+	for (const record of records) {
+		const safeId = encodeURIComponent(record.acpxRecordId);
+		const jsonFile = path.join(sessionDir, `${safeId}.json`);
+		try {
+			const stat = await fs$1.stat(jsonFile);
+			bytesFreed += stat.size;
+		} catch {}
+		await fs$1.unlink(jsonFile).catch(() => void 0);
+		if (options.includeHistory) for (const name of dirEntries) {
+			if (!isSessionStreamFile(name, safeId)) continue;
+			const filePath = path.join(sessionDir, name);
+			try {
+				const stat = await fs$1.stat(filePath);
+				bytesFreed += stat.size;
+			} catch {}
+			await fs$1.unlink(filePath).catch(() => void 0);
+		}
+	}
+	await rebuildSessionIndex(sessionDir).catch(() => {});
+	return {
+		pruned: records,
+		bytesFreed,
+		dryRun: false
+	};
+}
 //#endregion
 //#region src/permission-prompt.ts
 async function promptForPermission(options) {
@@ -875,7 +941,7 @@ async function defaultConfirmWrite(filePath, preview) {
 	});
 }
 function canPromptForPermission$2() {
-	return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+	return process.stdin.isTTY && process.stderr.isTTY;
 }
 var FileSystemHandlers = class {
 	rootDir;
@@ -1039,7 +1105,7 @@ async function promptForToolPermission(params) {
 	return await promptForPermission({ prompt: `\n[permission] Allow ${params.toolCall.title ?? "tool"} [${inferToolKind(params) ?? "other"}]? (y/N) ` });
 }
 function canPromptForPermission$1() {
-	return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+	return process.stdin.isTTY && process.stderr.isTTY;
 }
 function permissionModeSatisfies(actual, required) {
 	return PERMISSION_MODE_RANK[actual] >= PERMISSION_MODE_RANK[required];
@@ -1112,6 +1178,7 @@ function buildSpawnCommandOptions(command, options, platform = process.platform,
 }
 //#endregion
 //#region src/acp/client-process.ts
+const execFileAsync = promisify(execFile);
 function isoNow$1() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
@@ -1203,6 +1270,34 @@ function splitCommandLine(value) {
 function asAbsoluteCwd(cwd) {
 	return path.resolve(cwd);
 }
+async function resolveAgentSessionCwd(cwd, agentCommand, options = {}) {
+	const resolved = asAbsoluteCwd(cwd);
+	if (!shouldTranslateWslWindowsCwd(agentCommand, options)) return resolved;
+	const translated = (await (options.runWslpath ?? runWslpath)(resolved)).trim();
+	if (!translated) throw new Error(`wslpath returned an empty Windows path for cwd: ${resolved}`);
+	return translated;
+}
+function shouldTranslateWslWindowsCwd(agentCommand, options) {
+	if (!isWsl(options)) return false;
+	try {
+		const { command } = splitCommandLine(agentCommand);
+		return isWindowsExecutableCommand(command);
+	} catch {
+		return false;
+	}
+}
+function isWsl(options) {
+	if ((options.platform ?? process.platform) !== "linux") return false;
+	return (options.existsSync ?? fs.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
+}
+function isWindowsExecutableCommand(command) {
+	const normalized = command.replace(/\\/g, "/").toLowerCase();
+	return normalized.endsWith(".exe") || normalized.startsWith("/mnt/c/");
+}
+async function runWslpath(cwd) {
+	const { stdout } = await execFileAsync("wslpath", ["-w", cwd], { encoding: "utf8" });
+	return stdout;
+}
 function basenameToken(value) {
 	return path.basename(value).toLowerCase().replace(/\.(cmd|exe|bat)$/u, "");
 }
@@ -1304,46 +1399,8 @@ function compareVersionParts(left, right) {
 	return 0;
 }
 async function detectGeminiVersion(command) {
-	return await new Promise((resolve) => {
-		const child = spawn(command, ["--version"], buildSpawnCommandOptions(command, {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true
-		}));
-		let stdout = "";
-		let stderr = "";
-		let settled = false;
-		const finish = (value) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			child.removeAllListeners();
-			child.stdout?.removeAllListeners();
-			child.stderr?.removeAllListeners();
-			resolve(value);
-		};
-		const timer = setTimeout(() => {
-			child.kill("SIGKILL");
-			finish(void 0);
-		}, GEMINI_VERSION_TIMEOUT_MS);
-		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", () => {
-			finish(void 0);
-		});
-		child.once("close", () => {
-			finish(parseGeminiVersion(`${stdout}\n${stderr}`.split(/\r?\n/).map((line) => line.trim()).find((line) => /\d+\.\d+\.\d+/.test(line))));
-		});
-	});
+	const versionLine = (await readCommandOutput(command, ["--version"], GEMINI_VERSION_TIMEOUT_MS))?.split(/\r?\n/).map((line) => line.trim()).find((line) => /\d+\.\d+\.\d+/.test(line));
+	return parseGeminiVersion(versionLine);
 }
 async function resolveGeminiCommandArgs(command, args) {
 	if (basenameToken(command) !== "gemini" || !args.includes("--acp")) return [...args];
@@ -1425,46 +1482,57 @@ function buildClaudeCodeOptionsMeta(options) {
 	if (typeof options.model === "string" && options.model.trim().length > 0) claudeCodeOptions.model = options.model;
 	if (Array.isArray(options.allowedTools)) claudeCodeOptions.allowedTools = [...options.allowedTools];
 	if (typeof options.maxTurns === "number") claudeCodeOptions.maxTurns = options.maxTurns;
-	if (Object.keys(claudeCodeOptions).length === 0) return;
-	return { claudeCode: { options: claudeCodeOptions } };
+	const meta = {};
+	if (Object.keys(claudeCodeOptions).length > 0) meta.claudeCode = { options: claudeCodeOptions };
+	const systemPrompt = options.systemPrompt;
+	if (typeof systemPrompt === "string" && systemPrompt.length > 0) meta.systemPrompt = systemPrompt;
+	else if (systemPrompt && typeof systemPrompt === "object" && typeof systemPrompt.append === "string" && systemPrompt.append.length > 0) meta.systemPrompt = { append: systemPrompt.append };
+	if (Object.keys(meta).length === 0) return;
+	return meta;
 }
 //#endregion
 //#region src/acp/auth-env.ts
+const AUTH_ENV_PREFIX = "ACPX_AUTH_";
 function toEnvToken(value) {
 	return value.trim().replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
 }
-function buildAuthEnvKeys(methodId) {
+function buildAuthEnvKey(methodId) {
 	const token = toEnvToken(methodId);
-	const keys = new Set([methodId]);
-	if (token) {
-		keys.add(token);
-		keys.add(`ACPX_AUTH_${token}`);
-	}
-	return [...keys];
+	return token.length > 0 ? `${AUTH_ENV_PREFIX}${token}` : void 0;
 }
-const authEnvKeysCache = /* @__PURE__ */ new Map();
-function authEnvKeys(methodId) {
-	const cached = authEnvKeysCache.get(methodId);
-	if (cached) return cached;
-	const keys = buildAuthEnvKeys(methodId);
-	authEnvKeysCache.set(methodId, keys);
-	return keys;
+const authEnvKeyCache = /* @__PURE__ */ new Map();
+function authEnvKey(methodId) {
+	const cached = authEnvKeyCache.get(methodId);
+	if (cached !== void 0) return cached;
+	const key = buildAuthEnvKey(methodId);
+	authEnvKeyCache.set(methodId, key);
+	return key;
 }
 function readEnvCredential(methodId) {
-	for (const key of authEnvKeys(methodId)) {
-		const value = process.env[key];
-		if (typeof value === "string" && value.trim().length > 0) return value;
+	const key = authEnvKey(methodId);
+	if (!key) return;
+	const value = process.env[key];
+	if (typeof value === "string" && value.trim().length > 0) return value;
+}
+function promotePrefixedAuthEnvironment(env) {
+	for (const [key, value] of Object.entries(env)) {
+		if (!key.startsWith(AUTH_ENV_PREFIX)) continue;
+		if (typeof value !== "string" || value.trim().length === 0) continue;
+		const normalized = key.slice(10);
+		if (!normalized || env[normalized] != null) continue;
+		env[normalized] = value;
 	}
 }
 function buildAgentEnvironment(authCredentials) {
 	const env = { ...process.env };
+	promotePrefixedAuthEnvironment(env);
 	if (!authCredentials) return env;
 	for (const [methodId, credential] of Object.entries(authCredentials)) {
 		if (typeof credential !== "string" || credential.trim().length === 0) continue;
 		if (!methodId.includes("=") && !methodId.includes("\0") && env[methodId] == null) env[methodId] = credential;
 		const normalized = toEnvToken(methodId);
 		if (normalized) {
-			const prefixed = `ACPX_AUTH_${normalized}`;
+			const prefixed = `${AUTH_ENV_PREFIX}${normalized}`;
 			if (env[prefixed] == null) env[prefixed] = credential;
 			if (env[normalized] == null) env[normalized] = credential;
 		}
@@ -1570,7 +1638,7 @@ async function defaultConfirmExecute(commandLine) {
 	return await promptForPermission({ prompt: `\n[permission] Allow terminal command "${commandLine}"? (y/N) ` });
 }
 function canPromptForPermission() {
-	return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+	return process.stdin.isTTY && process.stderr.isTTY;
 }
 function waitMs(ms) {
 	return new Promise((resolve) => {
@@ -1966,6 +2034,7 @@ var AcpClient = class {
 	updateRuntimeOptions(options) {
 		if (options.permissionMode) this.options.permissionMode = options.permissionMode;
 		if (options.nonInteractivePermissions !== void 0) this.options.nonInteractivePermissions = options.nonInteractivePermissions;
+		if (options.terminal !== void 0) this.options.terminal = options.terminal;
 		if (options.permissionMode || options.nonInteractivePermissions !== void 0) {
 			this.filesystem.updatePermissionPolicy(this.options.permissionMode, this.options.nonInteractivePermissions);
 			this.terminalManager.updatePermissionPolicy(this.options.permissionMode, this.options.nonInteractivePermissions);
@@ -2057,7 +2126,7 @@ var AcpClient = class {
 							readTextFile: true,
 							writeTextFile: true
 						},
-						terminal: true
+						terminal: this.options.terminal !== false
 					},
 					clientInfo: {
 						name: "acpx",
@@ -2075,6 +2144,7 @@ var AcpClient = class {
 			this.log(`initialized protocol version ${initResult.protocolVersion}`);
 		} catch (error) {
 			startupFailure.dispose();
+			const normalizedError = await this.normalizeInitializeError(error, child, startupStderr);
 			try {
 				child.kill();
 			} catch {}
@@ -2082,7 +2152,7 @@ var AcpClient = class {
 				cause: error,
 				retryable: true
 			});
-			throw error;
+			throw normalizedError;
 		}
 	}
 	createTappedStream(base) {
@@ -2126,10 +2196,11 @@ var AcpClient = class {
 		const connection = this.getConnection();
 		const { command, args } = splitCommandLine(this.options.agentCommand);
 		const claudeAcp = isClaudeAcpCommand(command, args);
+		const sessionCwd = await resolveAgentSessionCwd(cwd, this.options.agentCommand);
 		let result;
 		try {
 			const createPromise = this.runConnectionRequest(() => connection.newSession({
-				cwd: asAbsoluteCwd(cwd),
+				cwd: sessionCwd,
 				mcpServers: this.options.mcpServers ?? [],
 				_meta: buildClaudeCodeOptionsMeta(this.options.sessionOptions)
 			}));
@@ -2154,6 +2225,7 @@ var AcpClient = class {
 	}
 	async loadSessionWithOptions(sessionId, cwd = this.options.cwd, options = {}) {
 		const connection = this.getConnection();
+		const sessionCwd = await resolveAgentSessionCwd(cwd, this.options.agentCommand);
 		const previousSuppression = this.suppressSessionUpdates;
 		const previousReplaySuppression = this.suppressReplaySessionUpdateMessages;
 		this.suppressSessionUpdates = previousSuppression || Boolean(options.suppressReplayUpdates);
@@ -2162,7 +2234,7 @@ var AcpClient = class {
 		try {
 			response = await this.runConnectionRequest(() => connection.loadSession({
 				sessionId,
-				cwd: asAbsoluteCwd(cwd),
+				cwd: sessionCwd,
 				mcpServers: this.options.mcpServers ?? []
 			}));
 			await this.waitForSessionUpdateDrain(options.replayIdleMs ?? REPLAY_IDLE_MS, options.replayDrainTimeoutMs ?? REPLAY_DRAIN_TIMEOUT_MS);
@@ -2255,7 +2327,7 @@ var AcpClient = class {
 	}
 	async closeSession(sessionId) {
 		const connection = this.getConnection();
-		await this.runConnectionRequest(() => connection.unstable_closeSession({ sessionId }));
+		await this.runConnectionRequest(() => connection.unstable_closeNes({ sessionId }));
 		if (this.loadedSessionId === sessionId) this.loadedSessionId = void 0;
 	}
 	async requestCancelActivePrompt() {
@@ -2402,6 +2474,20 @@ var AcpClient = class {
 			dispose: () => finish()
 		};
 	}
+	async normalizeInitializeError(error, child, startupStderr) {
+		if (error instanceof AgentStartupError) return error;
+		const connectionClosedDuringInitialize = error instanceof Error && /acp connection closed/i.test(error.message);
+		await waitForChildExit(child, 100);
+		const childExited = child.exitCode !== null || child.signalCode !== null;
+		if (!connectionClosedDuringInitialize && !childExited) return error;
+		return new AgentStartupError({
+			agentCommand: this.options.agentCommand,
+			exitCode: child.exitCode ?? null,
+			signal: child.signalCode ?? null,
+			stderrSummary: this.summarizeStartupStderr(startupStderr),
+			cause: error
+		});
+	}
 	selectAuthMethod(methods) {
 		for (const method of methods) {
 			const envCredential = readEnvCredential(method.id);
@@ -2851,6 +2937,7 @@ function cloneSessionAcpxState(state) {
 	return {
 		current_mode_id: state.current_mode_id,
 		desired_mode_id: state.desired_mode_id,
+		desired_config_options: state.desired_config_options ? { ...state.desired_config_options } : void 0,
 		current_model_id: state.current_model_id,
 		available_models: state.available_models ? [...state.available_models] : void 0,
 		available_commands: state.available_commands ? [...state.available_commands] : void 0,
@@ -2858,7 +2945,8 @@ function cloneSessionAcpxState(state) {
 		session_options: state.session_options ? {
 			model: state.session_options.model,
 			allowed_tools: state.session_options.allowed_tools ? [...state.session_options.allowed_tools] : void 0,
-			max_turns: state.session_options.max_turns
+			max_turns: state.session_options.max_turns,
+			...state.session_options.system_prompt !== void 0 ? { system_prompt: typeof state.session_options.system_prompt === "string" ? state.session_options.system_prompt : { append: state.session_options.system_prompt.append } } : {}
 		} : void 0
 	};
 }
@@ -2990,6 +3078,14 @@ function normalizeModelId(modelId) {
 function getDesiredModeId(state) {
 	return normalizeModeId(state?.desired_mode_id);
 }
+function getDesiredConfigOptions(state) {
+	const desired = state?.desired_config_options;
+	if (!desired) return {};
+	return Object.fromEntries(Object.entries(desired).flatMap(([configId, value]) => {
+		const normalizedConfigId = normalizeModeId(configId);
+		return normalizedConfigId && typeof value === "string" ? [[normalizedConfigId, value]] : [];
+	}));
+}
 function setDesiredModeId(record, modeId) {
 	const acpx = ensureAcpxState(record.acpx);
 	const normalized = normalizeModeId(modeId);
@@ -2997,6 +3093,17 @@ 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 getDesiredModelId(state) {
 	return normalizeModelId(state?.session_options?.model);
 }
@@ -3006,7 +3113,7 @@ function setDesiredModelId(record, modelId) {
 	const sessionOptions = { ...acpx.session_options };
 	if (normalized) sessionOptions.model = normalized;
 	else delete sessionOptions.model;
-	if (typeof sessionOptions.model === "string" || Array.isArray(sessionOptions.allowed_tools) || typeof sessionOptions.max_turns === "number") acpx.session_options = sessionOptions;
+	if (typeof sessionOptions.model === "string" || Array.isArray(sessionOptions.allowed_tools) || typeof sessionOptions.max_turns === "number" || sessionOptions.system_prompt !== void 0) acpx.session_options = sessionOptions;
 	else delete acpx.session_options;
 	record.acpx = acpx;
 }
@@ -3025,6 +3132,30 @@ function syncAdvertisedModelState(record, models) {
 	record.acpx = acpx;
 }
 //#endregion
+//#region src/acp/model-support.ts
+var RequestedModelUnsupportedError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "RequestedModelUnsupportedError";
+	}
+};
+function supportsLegacyClaudeCodeModelMetadata(agentCommand) {
+	if (!agentCommand) return false;
+	const { command, args } = splitCommandLine(agentCommand);
+	return isClaudeAcpCommand(command, args);
+}
+function formatAvailableModelIds(models) {
+	const ids = models?.availableModels.map((model) => model.modelId.trim()).filter((modelId) => modelId.length > 0) ?? [];
+	return ids.length > 0 ? ids.join(", ") : "none advertised";
+}
+function assertRequestedModelSupported(params) {
+	if (!params.models) {
+		if (supportsLegacyClaudeCodeModelMetadata(params.agentCommand)) return;
+		throw new RequestedModelUnsupportedError(`Cannot ${params.context === "replay" ? "replay saved model" : "apply --model"} "${params.requestedModel}": the ACP agent did not advertise model support. Generic model selection requires ACP models plus session/set_model support, or an adapter-specific startup model flag.`);
+	}
+	if (!new Set(params.models.availableModels.map((model) => model.modelId)).has(params.requestedModel)) throw new RequestedModelUnsupportedError(`Cannot ${params.context === "replay" ? "replay saved model" : "apply --model"} "${params.requestedModel}": the ACP agent did not advertise that model. Available models: ${formatAvailableModelIds(params.models)}.`);
+}
+//#endregion
 //#region src/runtime/engine/lifecycle.ts
 function applyLifecycleSnapshotToRecord(record, snapshot) {
 	if (!snapshot) return;
@@ -3099,9 +3230,15 @@ async function replayDesiredMode(params) {
 	}
 }
 async function replayDesiredModel(params) {
-	if (!params.desiredModelId || !params.models) return;
-	if (params.models.currentModelId === params.desiredModelId) return;
+	if (!params.desiredModelId) return;
 	try {
+		assertRequestedModelSupported({
+			requestedModel: params.desiredModelId,
+			models: params.models,
+			agentCommand: params.record.agentCommand,
+			context: "replay"
+		});
+		if (!params.models || params.models.currentModelId === params.desiredModelId) return;
 		await withTimeout(params.client.setSessionModel(params.sessionId, params.desiredModelId), params.timeoutMs);
 		if (params.verbose) process.stderr.write(`[acpx] replayed desired model ${params.desiredModelId} on fresh ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
 	} catch (error) {
@@ -3111,6 +3248,17 @@ async function replayDesiredModel(params) {
 		});
 	}
 }
+async function replayDesiredConfigOptions(params) {
+	for (const [configId, value] of Object.entries(params.desiredConfigOptions)) try {
+		await withTimeout(params.client.setSessionConfigOption(params.sessionId, configId, value), params.timeoutMs);
+		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
+		});
+	}
+}
 function restoreOriginalSessionState(params) {
 	params.record.acpSessionId = params.sessionId;
 	params.record.agentSessionId = params.agentSessionId;
@@ -3123,6 +3271,7 @@ async function connectAndLoadSession(options) {
 	const originalAgentSessionId = record.agentSessionId;
 	const desiredModeId = getDesiredModeId(record.acpx);
 	const desiredModelId = getDesiredModelId(record.acpx);
+	const desiredConfigOptions = getDesiredConfigOptions(record.acpx);
 	const storedProcessAlive = isProcessAlive(record.pid);
 	const shouldReconnect = Boolean(record.pid) && !storedProcessAlive;
 	if (options.verbose) {
@@ -3189,10 +3338,19 @@ async function connectAndLoadSession(options) {
 				sessionId,
 				desiredModelId,
 				previousSessionId: originalSessionId,
+				record,
 				models: sessionModels,
 				timeoutMs: options.timeoutMs,
 				verbose: options.verbose
 			});
+			await replayDesiredConfigOptions({
+				client,
+				sessionId,
+				desiredConfigOptions,
+				previousSessionId: originalSessionId,
+				timeoutMs: options.timeoutMs,
+				verbose: options.verbose
+			});
 		} catch (error) {
 			restoreOriginalSessionState({
 				record,
@@ -3217,6 +3375,14 @@ async function connectAndLoadSession(options) {
 }
 //#endregion
 //#region src/runtime/engine/session-options.ts
+function mergeSessionOptions(preferred, fallback) {
+	const merged = { ...fallback };
+	if (preferred?.model !== void 0) merged.model = preferred.model;
+	if (preferred?.allowedTools !== void 0) merged.allowedTools = preferred.allowedTools;
+	if (preferred?.maxTurns !== void 0) merged.maxTurns = preferred.maxTurns;
+	if (preferred?.systemPrompt !== void 0) merged.systemPrompt = preferred.systemPrompt;
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
 function sessionOptionsFromRecord(record) {
 	const stored = record.acpx?.session_options;
 	if (!stored) return;
@@ -3224,6 +3390,9 @@ function sessionOptionsFromRecord(record) {
 	if (typeof stored.model === "string" && stored.model.trim().length > 0) sessionOptions.model = stored.model;
 	if (Array.isArray(stored.allowed_tools)) sessionOptions.allowedTools = [...stored.allowed_tools];
 	if (typeof stored.max_turns === "number") sessionOptions.maxTurns = stored.max_turns;
+	const storedSystemPrompt = stored.system_prompt;
+	if (typeof storedSystemPrompt === "string" && storedSystemPrompt.length > 0) sessionOptions.systemPrompt = storedSystemPrompt;
+	else if (storedSystemPrompt && typeof storedSystemPrompt === "object" && typeof storedSystemPrompt.append === "string" && storedSystemPrompt.append.length > 0) sessionOptions.systemPrompt = { append: storedSystemPrompt.append };
 	return Object.keys(sessionOptions).length > 0 ? sessionOptions : void 0;
 }
 //#endregion
@@ -3254,6 +3423,7 @@ async function withConnectedSession(options) {
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
+		terminal: options.terminal,
 		verbose: options.verbose,
 		sessionOptions: sessionOptionsFromRecord(record)
 	}) ?? new AcpClient({
@@ -3264,6 +3434,7 @@ async function withConnectedSession(options) {
 		nonInteractivePermissions: options.nonInteractivePermissions,
 		authCredentials: options.authCredentials,
 		authPolicy: options.authPolicy,
+		terminal: options.terminal,
 		verbose: options.verbose,
 		sessionOptions: sessionOptionsFromRecord(record)
 	});
@@ -3338,8 +3509,13 @@ async function runPromptTurn(params) {
 	try {
 		const promptPromise = params.client.prompt(params.sessionId, params.prompt);
 		await params.onPromptStarted?.();
+		const response = await withTimeout(promptPromise, params.timeoutMs);
+		await params.client.waitForSessionUpdatesIdle?.({
+			idleMs: SESSION_REPLY_IDLE_MS,
+			timeoutMs: SESSION_REPLY_DRAIN_TIMEOUT_MS
+		}).catch(() => {});
 		return {
-			stopReason: (await withTimeout(promptPromise, params.timeoutMs)).stopReason,
+			stopReason: response.stopReason,
 			source: "rpc"
 		};
 	} catch (error) {
@@ -3356,6 +3532,6 @@ async function runPromptTurn(params) {
 	}
 }
 //#endregion
-export { resolveSessionRecord as A, serializeSessionRecordForDisk as B, findGitRepositoryRoot as C, listSessions as D, isoNow$2 as E, sessionBaseDir$1 as F, DEFAULT_AGENT_NAME as G, TimeoutError as H, sessionEventActivePath as I, resolveAgentCommand as J, listBuiltInAgents as K, sessionEventLockPath as L, parseSessionRecord as M, DEFAULT_EVENT_SEGMENT_MAX_BYTES as N, listSessionsForAgent as O, defaultSessionEventLog as P, sessionEventSegmentPath as R, absolutePath as S, findSessionByDirectoryWalk as T, withInterrupt as U, InterruptedError as V, withTimeout as W, recordSessionUpdate as _, applyConversation as a, permissionModeSatisfies as b, setCurrentModelId as c, syncAdvertisedModelState as d, cloneSessionAcpxState as f, recordPromptSubmission as g, recordClientOperation as h, connectAndLoadSession as i, writeSessionRecord as j, normalizeName as k, setDesiredModeId as l, createSessionConversation as m, withConnectedSession as n, applyLifecycleSnapshotToRecord as o, cloneSessionConversation as p, normalizeAgentName$1 as q, sessionOptionsFromRecord as r, reconcileAgentSessionId as s, runPromptTurn as t, setDesiredModelId as u, trimConversationForRuntime as v, findSession as w, DEFAULT_HISTORY_LIMIT as x, AcpClient as y, assertPersistedKeyPolicy as z };
+export { listSessions as A, sessionEventActivePath as B, permissionModeSatisfies as C, findSession as D, findGitRepositoryRoot as E, writeSessionRecord as F, InterruptedError as G, sessionEventSegmentPath as H, parseSessionRecord as I, withTimeout as J, TimeoutError as K, DEFAULT_EVENT_SEGMENT_MAX_BYTES as L, normalizeName as M, pruneSessions as N, findSessionByDirectoryWalk as O, resolveSessionRecord as P, resolveAgentCommand as Q, defaultSessionEventLog as R, AcpClient as S, absolutePath as T, assertPersistedKeyPolicy as U, sessionEventLockPath as V, serializeSessionRecordForDisk as W, listBuiltInAgents as X, DEFAULT_AGENT_NAME as Y, normalizeAgentName$1 as Z, createSessionConversation as _, connectAndLoadSession as a, recordSessionUpdate as b, reconcileAgentSessionId as c, setDesiredConfigOption as d, setDesiredModeId as f, cloneSessionConversation as g, cloneSessionAcpxState as h, sessionOptionsFromRecord as i, listSessionsForAgent as j, isoNow$2 as k, assertRequestedModelSupported as l, syncAdvertisedModelState as m, withConnectedSession as n, applyConversation as o, setDesiredModelId as p, withInterrupt as q, mergeSessionOptions as r, applyLifecycleSnapshotToRecord as s, runPromptTurn as t, setCurrentModelId as u, recordClientOperation as v, DEFAULT_HISTORY_LIMIT as w, trimConversationForRuntime as x, recordPromptSubmission as y, sessionBaseDir$1 as z };
 
-//# sourceMappingURL=prompt-turn-CXMtXBl-.js.map
+//# sourceMappingURL=prompt-turn-BY5SwU1F.js.map