acpx 0.15.1 → 0.17.0

package/dist/runtime.js

@@ -1,4 +1,8 @@
-import { A as RequestedModelUnsupportedError, At as DEFAULT_AGENT_NAME, Bt as extractAcpError, C as sessionOptionsFromRecord, D as AcpClient, E as reconcileAgentSessionId, Ft as resolveCanonicalAgentName, M as modelStateFromConfigOptions, Mt as normalizeAgentName, N as normalizeAgentCommandInput, Nt as resolveAgentArgv, O as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, Pt as resolveAgentCommand, Q as assertPersistedKeyPolicy, S as persistSessionOptions, T as applyLifecycleSnapshotToRecord, Tt as textPrompt, Vt as isAcpResourceNotFoundError, Z as createAtomicWriteTempPath, _ as recordPromptSubmission, a as applyConfigOptionSelection, b as advertisedModelState, c as applyRequestedModelIfAdvertised, ct as serializeSessionRecordForDisk, d as setDesiredModeId, dt as defaultSessionEventLog, f as syncAdvertisedModelState, g as recordClientOperation, h as createSessionConversation, i as connectAndLoadSession, j as isRequestedModelUnsupportedError, jt as listBuiltInAgents, k as REQUESTED_MODEL_UNSUPPORTED_REASONS, kt as withTimeout, l as currentModelIdFromSetModelResponse, m as cloneSessionConversation, n as runPromptTurn, o as applyConfigOptionsToRecord, p as cloneSessionAcpxState, r as withConnectedSession, s as applyModelSelection, st as parseSessionRecord, t as LiveSessionCheckpoint, u as setCurrentModelId, v as recordSessionUpdate, w as applyConversation, y as trimConversationForRuntime, zt as normalizeOutputError } from "./live-checkpoint-sB7dFOYR.js";
+import { C as textPrompt, D as findSession, F as resolveSessionRecord, L as assertPersistedKeyPolicy, P as readSessionRecord, R as parseSessionRecord, gt as extractAcpError, mt as writePrivateJsonFile, t as tryCancelOnRunningOwner, vt as isAcpResourceNotFoundError, z as serializeSessionRecordForDisk } from "./ipc-D3akHMEq.js";
+import { A as setDesiredModeId, B as recordClientOperation, C as withConnectedSession, D as applyInitialModelSelection, E as applyConfigOptionsToRecord, F as createInitialSessionRecord, G as AcpClient, H as recordSessionUpdate, I as reconcileAgentSessionId, J as RequestedModelUnsupportedError, K as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, L as cloneSessionAcpxState, M as sessionOptionsFromRecord, N as applyConversation, O as applyModelSelection, P as applyLifecycleSnapshotToRecord, R as cloneSessionConversation, T as applyConfigOptionSelection, U as trimConversationForRuntime, V as recordPromptSubmission, W as advertisedModelState, Y as isRequestedModelUnsupportedError, _ as cancelSessionPrompt, c as LiveSessionCheckpoint, ct as normalizeOutputError, h as ensureSession, it as assertControlAuthority, j as persistSessionOptions, k as applyRequestedModelIfAdvertised, l as runPromptTurn, ot as withTimeout, q as REQUESTED_MODEL_UNSUPPORTED_REASONS, r as sendSession, s as DISCARD_OUTPUT_FORMATTER, v as closeSession, w as connectAndLoadSession } from "./queue-owner-runtime--IbbndGz.js";
+import { D as normalizeAgentCommandInput, a as createAgentRegistry, i as DEFAULT_AGENT_NAME } from "./agent-registry-DU6mhZBL.js";
+import { t as watchSession } from "./watch-BbBxO-kb.js";
+import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -84,8 +88,7 @@ const STATUS_TEXT_RESOLVERS = {
 	available_commands_update: availableCommandsStatusText,
 	current_mode_update: currentModeStatusText,
 	config_option_update: configOptionStatusText,
-	session_info_update: sessionInfoStatusText,
-	plan: planStatusText
+	session_info_update: sessionInfoStatusText
 };
 function availableCommandsStatusText(payload) {
 	const commands = Array.isArray(payload.availableCommands) ? payload.availableCommands : [];
@@ -108,6 +111,51 @@ function planStatusText(payload) {
 	const content = asTrimmedString((Array.isArray(payload.entries) ? payload.entries : []).find((entry) => isRecord(entry))?.content);
 	return content ? `plan: ${content}` : null;
 }
+function isPlanEntryStatus(value) {
+	return value === "pending" || value === "in_progress" || value === "completed";
+}
+function isPlanEntryPriority(value) {
+	return value === "high" || value === "medium" || value === "low";
+}
+function planUpdateEvent(payload) {
+	const raw = payload.entries;
+	const entries = normalizePlanEntries(raw);
+	if (Array.isArray(raw) && raw.length === 0) return {
+		type: "status",
+		text: "plan updated",
+		tag: "plan",
+		entries: []
+	};
+	const text = planStatusText(payload) ?? (entries.length > 0 ? `plan: ${entries[0]?.content}` : null);
+	if (!text) return null;
+	return {
+		type: "status",
+		text,
+		tag: "plan",
+		...entries.length > 0 ? { entries } : {}
+	};
+}
+function normalizePlanEntries(value) {
+	if (!Array.isArray(value)) return [];
+	const entries = [];
+	for (const entry of value) {
+		const normalized = normalizePlanEntry(entry);
+		if (normalized) entries.push(normalized);
+	}
+	return entries;
+}
+function normalizePlanEntry(value) {
+	if (!isRecord(value)) return;
+	const content = asTrimmedString(value.content);
+	const status = asTrimmedString(value.status);
+	if (!content || !isPlanEntryStatus(status)) return;
+	const priority = asTrimmedString(value.priority);
+	return {
+		content,
+		status,
+		...isPlanEntryPriority(priority) ? { priority } : {}
+	};
+}
 /**
 * Documented allowlist for text_delta.meta origin fields.
 * Only these keys may be copied from ACP update `_meta`.
@@ -371,7 +419,7 @@ const PROMPT_EVENT_PARSERS = {
 	current_mode_update: (payload) => statusUpdateEvent("current_mode_update", payload),
 	config_option_update: (payload) => statusUpdateEvent("config_option_update", payload),
 	session_info_update: (payload) => statusUpdateEvent("session_info_update", payload),
-	plan: (payload) => statusUpdateEvent("plan", payload),
+	plan: planUpdateEvent,
 	client_operation: clientOperationEvent,
 	update: updateStatusEvent,
 	done: () => null,
@@ -498,6 +546,88 @@ function updateStatusEvent(payload, tag) {
 	} : null;
 }
 //#endregion
+//#region src/runtime/public/probe.ts
+function isPrimitiveDetail(value) {
+	return value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
+}
+function formatFunctionDetail(value) {
+	return value.name ? `[Function ${value.name}]` : "[Function]";
+}
+function serializeRuntimeDetail(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, nested) => {
+		if (nested instanceof Error) return nested.message || nested.name;
+		if (nested && typeof nested === "object") {
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+		}
+		return nested;
+	}) ?? "undefined";
+}
+function formatRuntimeDetail(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	if (isPrimitiveDetail(value)) return String(value);
+	if (typeof value === "function") return formatFunctionDetail(value);
+	try {
+		return serializeRuntimeDetail(value);
+	} catch {
+		return "unserializable object";
+	}
+}
+function normalizeRuntimeDetails(details) {
+	return details?.map((detail) => formatRuntimeDetail(detail));
+}
+async function probeRuntime(options, deps = {}) {
+	const agentName = options.probeAgent?.trim() || "codex";
+	const agentCommand = normalizeAgentCommandInput(options.agentRegistry.resolve(agentName));
+	const client = createProbeClient(options, agentName, agentCommand, deps);
+	try {
+		await client.start();
+		return {
+			ok: true,
+			message: "embedded ACP runtime ready",
+			details: [
+				`agent=${agentName}`,
+				`command=${agentCommand.agentCommand}`,
+				`cwd=${options.cwd}`,
+				...client.initializeResult?.protocolVersion ? [`protocolVersion=${client.initializeResult.protocolVersion}`] : []
+			]
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			message: "embedded ACP runtime probe failed",
+			details: [
+				`agent=${agentName}`,
+				`command=${agentCommand.agentCommand}`,
+				`cwd=${options.cwd}`,
+				formatRuntimeDetail(error)
+			]
+		};
+	} finally {
+		await client.close().catch(() => {});
+	}
+}
+function createProbeClient(options, agentName, agentCommand, deps) {
+	const clientOptions = {
+		...agentCommand,
+		cwd: options.cwd,
+		agentProcessEnv: options.agentProcessEnv,
+		mcpServers: typeof options.mcpServers === "function" ? [] : [...options.mcpServers ?? []],
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		processLifecycle: options.processLifecycle,
+		processLaunchScope: {
+			kind: "runtime-probe",
+			agent: agentName
+		},
+		verbose: options.verbose
+	};
+	return deps.clientFactory?.(clientOptions) ?? new AcpClient(clientOptions);
+}
+//#endregion
 //#region src/runtime/engine/reuse-policy.ts
 function shouldReuseExistingRecord(record, params) {
 	if (record.acpx?.reset_on_next_ensure === true) return false;
@@ -513,7 +643,100 @@ function sameArgv(left, right) {
 	return leftValues.length === rightValues.length && leftValues.every((value, index) => value === rightValues[index]);
 }
 //#endregion
-//#region src/runtime/engine/manager.ts
+//#region src/runtime/engine/status.ts
+function runtimeStatusFromRecord(record) {
+	return {
+		...record.lastRequestId ? { lastRequestId: record.lastRequestId } : {},
+		summary: statusSummary(record),
+		acpxRecordId: record.acpxRecordId,
+		backendSessionId: record.acpSessionId,
+		agentSessionId: record.agentSessionId,
+		...buildModelsField(record),
+		...buildUsageField(record),
+		...buildAvailableCommandsField(record),
+		details: {
+			cwd: record.cwd,
+			lastUsedAt: record.lastUsedAt,
+			closed: record.closed === true,
+			...record.acpx?.config_options !== void 0 ? { configOptions: structuredClone(record.acpx.config_options) } : {}
+		}
+	};
+}
+function statusSummary(record) {
+	return [
+		`session=${record.acpxRecordId}`,
+		`backendSessionId=${record.acpSessionId}`,
+		record.agentSessionId ? `agentSessionId=${record.agentSessionId}` : null,
+		record.pid != null ? `pid=${record.pid}` : null,
+		record.closed ? "closed" : "open"
+	].filter(Boolean).join(" ");
+}
+function buildModelsField(record) {
+	const { available_models: available = [], current_model_id: currentModelId } = record.acpx ?? {};
+	if (available.length === 0 && currentModelId === void 0) return {};
+	return { models: {
+		...currentModelId !== void 0 ? { currentModelId } : {},
+		availableModelIds: [...available],
+		...buildModelNamesField(record.acpx)
+	} };
+}
+function buildModelNamesField(state) {
+	const models = advertisedModelState(state);
+	return models && (models.configId || state?.available_model_names !== void 0) ? { availableModels: models.availableModels } : {};
+}
+function tokenUsageToBreakdown(usage) {
+	if (!usage) return;
+	const breakdown = {};
+	assignUsageBreakdownField(breakdown, "inputTokens", usage.input_tokens);
+	assignUsageBreakdownField(breakdown, "outputTokens", usage.output_tokens);
+	assignUsageBreakdownField(breakdown, "cachedReadTokens", usage.cache_read_input_tokens);
+	assignUsageBreakdownField(breakdown, "cachedWriteTokens", usage.cache_creation_input_tokens);
+	assignUsageBreakdownField(breakdown, "thoughtTokens", usage.thought_tokens);
+	assignUsageBreakdownField(breakdown, "totalTokens", usage.total_tokens);
+	return Object.keys(breakdown).length > 0 ? breakdown : void 0;
+}
+function assignUsageBreakdownField(breakdown, key, value) {
+	if (value !== void 0) breakdown[key] = value;
+}
+function buildUsageField(record) {
+	const cumulative = tokenUsageToBreakdown(record.cumulative_token_usage);
+	const perRequestEntries = Object.entries(record.request_token_usage ?? {}).map(([id, value]) => [id, tokenUsageToBreakdown(value)]).filter((entry) => entry[1] !== void 0);
+	const perRequest = perRequestEntries.length > 0 ? Object.fromEntries(perRequestEntries) : void 0;
+	const cost = record.cumulative_cost;
+	const usage = {
+		...cumulative ? { cumulative } : {},
+		...cost ? { cost } : {},
+		...perRequest ? { perRequest } : {}
+	};
+	return Object.keys(usage).length > 0 ? { usage } : {};
+}
+function buildAvailableCommandsField(record) {
+	const commands = record.acpx?.available_commands;
+	if (!commands || commands.length === 0) return {};
+	const availableCommands = commands.map((command) => runtimeAvailableCommand(command)).filter((command) => command !== void 0);
+	return availableCommands.length > 0 ? { availableCommands } : {};
+}
+function runtimeAvailableCommand(command) {
+	if (typeof command === "string") {
+		const name = command.trim();
+		return name ? { name } : void 0;
+	}
+	const record = commandRecord(command);
+	if (!record) return;
+	const name = asOptionalString(record.name);
+	if (!name) return;
+	const runtimeCommand = { name };
+	const description = asOptionalString(record.description);
+	if (description) runtimeCommand.description = description;
+	if (typeof record.has_input === "boolean") runtimeCommand.hasInput = record.has_input;
+	return runtimeCommand;
+}
+function commandRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+//#endregion
+//#region src/runtime/engine/turn.ts
 function createDeferred() {
 	let resolve;
 	let reject;
@@ -526,22 +749,6 @@ function createDeferred() {
 		reject
 	};
 }
-async function settleAttempt(run) {
-	try {
-		return {
-			ok: true,
-			value: await run()
-		};
-	} catch (error) {
-		return {
-			ok: false,
-			error
-		};
-	}
-}
-function firstFailedAttempt(attempts) {
-	return attempts.find((attempt) => !attempt.ok);
-}
 var AsyncEventQueue = class {
 	items = [];
 	waits = [];
@@ -578,17 +785,6 @@ var AsyncEventQueue = class {
 		}
 	}
 };
-function isoNow() {
-	return (/* @__PURE__ */ new Date()).toISOString();
-}
-function isUnsupportedSessionCloseError(error) {
-	const acp = extractAcpError(error);
-	if (!acp) return false;
-	if (acp.code === -32601 || acp.code === -32602) return true;
-	if (acp.code !== -32603 || !acp.data || typeof acp.data !== "object") return false;
-	const details = acp.data.details;
-	return typeof details === "string" && details.toLowerCase().includes("invalid params");
-}
 function toPromptInput(text, attachments) {
 	if (!attachments || attachments.length === 0) return text;
 	const blocks = [];
@@ -617,34 +813,6 @@ function toPromptInput(text, attachments) {
 	}
 	return blocks.length > 0 ? blocks : textPrompt(text);
 }
-function createInitialRecord(params) {
-	const now = isoNow();
-	return {
-		schema: "acpx.session.v1",
-		acpxRecordId: params.recordId,
-		acpSessionId: params.sessionId,
-		agentSessionId: params.agentSessionId,
-		agentCommand: params.agentCommand,
-		agentArgv: params.agentArgv,
-		cwd: params.cwd,
-		name: params.sessionName,
-		createdAt: now,
-		lastUsedAt: now,
-		lastSeq: 0,
-		eventLog: defaultSessionEventLog(params.recordId),
-		closed: false,
-		closedAt: void 0,
-		...createSessionConversation(now),
-		acpx: {}
-	};
-}
-function createRecordId(sessionKey, mode) {
-	if (mode === "persistent") return sessionKey;
-	return `${sessionKey}:oneshot:${randomUUID()}`;
-}
-function resumePolicyForSessionMode(mode) {
-	return mode === "persistent" ? "same-session-only" : "allow-new";
-}
 function legacyTerminalEventFromTurnResult(result) {
 	if (result.status === "failed") return {
 		type: "error",
@@ -659,82 +827,41 @@ function legacyTerminalEventFromTurnResult(result) {
 		...result._meta === void 0 ? {} : { _meta: result._meta }
 	};
 }
-function statusSummary(record) {
-	return [
-		`session=${record.acpxRecordId}`,
-		`backendSessionId=${record.acpSessionId}`,
-		record.agentSessionId ? `agentSessionId=${record.agentSessionId}` : null,
-		record.pid != null ? `pid=${record.pid}` : null,
-		record.closed ? "closed" : "open"
-	].filter(Boolean).join(" ");
-}
-function buildModelsField(record) {
-	const available = record.acpx?.available_models;
-	const currentModelId = record.acpx?.current_model_id;
-	if (!available || available.length === 0) return currentModelId === void 0 ? {} : { models: {
-		currentModelId,
-		availableModelIds: []
-	} };
-	return { models: {
-		...currentModelId !== void 0 ? { currentModelId } : {},
-		availableModelIds: [...available]
-	} };
-}
-function tokenUsageToBreakdown(usage) {
-	if (!usage) return;
-	const breakdown = {};
-	assignUsageBreakdownField(breakdown, "inputTokens", usage.input_tokens);
-	assignUsageBreakdownField(breakdown, "outputTokens", usage.output_tokens);
-	assignUsageBreakdownField(breakdown, "cachedReadTokens", usage.cache_read_input_tokens);
-	assignUsageBreakdownField(breakdown, "cachedWriteTokens", usage.cache_creation_input_tokens);
-	assignUsageBreakdownField(breakdown, "thoughtTokens", usage.thought_tokens);
-	assignUsageBreakdownField(breakdown, "totalTokens", usage.total_tokens);
-	return Object.keys(breakdown).length > 0 ? breakdown : void 0;
-}
-function assignUsageBreakdownField(breakdown, key, value) {
-	if (value !== void 0) breakdown[key] = value;
+//#endregion
+//#region src/runtime/engine/manager.ts
+async function settleAttempt(run) {
+	try {
+		return {
+			ok: true,
+			value: await run()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error
+		};
+	}
 }
-function buildUsageField(record) {
-	const cumulative = tokenUsageToBreakdown(record.cumulative_token_usage);
-	const perRequestEntries = Object.entries(record.request_token_usage ?? {}).map(([id, value]) => [id, tokenUsageToBreakdown(value)]).filter((entry) => entry[1] !== void 0);
-	const perRequest = perRequestEntries.length > 0 ? Object.fromEntries(perRequestEntries) : void 0;
-	const cost = record.cumulative_cost;
-	const usage = {
-		...cumulative ? { cumulative } : {},
-		...cost ? { cost } : {},
-		...perRequest ? { perRequest } : {}
-	};
-	return Object.keys(usage).length > 0 ? { usage } : {};
+function firstFailedAttempt(attempts) {
+	return attempts.find((attempt) => !attempt.ok);
 }
-function buildAvailableCommandsField(record) {
-	const commands = record.acpx?.available_commands;
-	if (!commands || commands.length === 0) return {};
-	const availableCommands = commands.map((command) => runtimeAvailableCommand(command)).filter((command) => command !== void 0);
-	return availableCommands.length > 0 ? { availableCommands } : {};
+function isoNow() {
+	return (/* @__PURE__ */ new Date()).toISOString();
 }
-function runtimeAvailableCommand(command) {
-	if (typeof command === "string") {
-		const name = command.trim();
-		return name ? { name } : void 0;
-	}
-	const record = commandRecord(command);
-	if (!record) return;
-	const name = trimmedField(record.name);
-	if (!name) return;
-	const runtimeCommand = { name };
-	const description = trimmedField(record.description);
-	if (description) runtimeCommand.description = description;
-	if (typeof record.has_input === "boolean") runtimeCommand.hasInput = record.has_input;
-	return runtimeCommand;
+function isUnsupportedSessionCloseError(error) {
+	const acp = extractAcpError(error);
+	if (!acp) return false;
+	if (acp.code === -32601 || acp.code === -32602) return true;
+	if (acp.code !== -32603 || !acp.data || typeof acp.data !== "object") return false;
+	const details = acp.data.details;
+	return typeof details === "string" && details.toLowerCase().includes("invalid params");
 }
-function commandRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	return value;
+function createRecordId(sessionKey, mode) {
+	if (mode === "persistent") return sessionKey;
+	return `${sessionKey}:oneshot:${randomUUID()}`;
 }
-function trimmedField(value) {
-	if (typeof value !== "string") return;
-	const trimmed = value.trim();
-	return trimmed ? trimmed : void 0;
+function resumePolicyForSessionMode(mode) {
+	return mode === "persistent" ? "same-session-only" : "allow-new";
 }
 function advertisedConfigOptionIds(record) {
 	const configOptions = record.acpx?.config_options;
@@ -780,20 +907,117 @@ var AcpRuntimeManager = class {
 	deps;
 	activeControllers = /* @__PURE__ */ new Map();
 	retainedSessionOwners = /* @__PURE__ */ new Map();
+	retiringSessionOwners = /* @__PURE__ */ new Set();
 	pendingOneShotRecordIds = /* @__PURE__ */ new Map();
 	ensureSessionLocks = /* @__PURE__ */ new Map();
 	runtimeOperationLocks = /* @__PURE__ */ new Map();
+	sessionTasks = /* @__PURE__ */ new Map();
 	closingActiveRecords = /* @__PURE__ */ new Set();
+	liveClients = /* @__PURE__ */ new Set();
+	pendingTasks = /* @__PURE__ */ new Set();
+	shuttingDown = false;
+	shutdownTask;
 	constructor(options, deps = {}) {
 		this.options = options;
 		this.deps = deps;
 	}
 	createClient(options) {
+		this.assertOpen();
 		const clientOptions = {
 			...options,
-			agentProcessEnv: this.options.agentProcessEnv
+			agentProcessEnv: this.options.agentProcessEnv,
+			processLifecycle: {
+				...options.processLifecycle,
+				onBeforeSpawn: async (launch) => {
+					this.assertOpen();
+					await options.processLifecycle?.onBeforeSpawn?.(launch);
+					this.assertOpen();
+				},
+				onSpawned: async (process) => {
+					this.assertOpen();
+					await options.processLifecycle?.onSpawned?.(process);
+					this.assertOpen();
+				}
+			}
+		};
+		const client = this.deps.clientFactory?.(clientOptions) ?? new AcpClient(clientOptions);
+		this.liveClients.add(client);
+		return client;
+	}
+	async probe() {
+		let client;
+		try {
+			return await probeRuntime(this.options, { clientFactory: (options) => client = this.createClient(options) });
+		} finally {
+			if (client) this.liveClients.delete(client);
+		}
+	}
+	assertOpen() {
+		if (this.shuttingDown) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
+	}
+	shutdown() {
+		if (!this.shutdownTask) {
+			this.shuttingDown = true;
+			this.shutdownTask = this.shutdownOwnedClients();
+		}
+		return this.shutdownTask;
+	}
+	async shutdownOwnedClients() {
+		const closed = await Promise.allSettled([...this.liveClients].map(async (client) => {
+			client.requestCancelActivePrompt().catch(() => {});
+			await this.closeClient(client);
+		}));
+		await Promise.allSettled([
+			...this.ensureSessionLocks.values(),
+			...this.runtimeOperationLocks.values(),
+			...this.pendingTasks
+		]);
+		await Promise.all([...this.retainedSessionOwners.values()].map(async (owner) => {
+			this.removeRetainedSessionOwner(owner);
+			await this.stopSessionOwner(owner);
+		}));
+		const errors = [];
+		for (const result of closed) if (result.status === "rejected") errors.push(result.reason);
+		if (errors.length) throw new AggregateError(errors, "ACP runtime shutdown failed.");
+		this.retiringSessionOwners.clear();
+	}
+	trackTask(task) {
+		this.pendingTasks.add(task);
+		const remove = () => {
+			this.pendingTasks.delete(task);
 		};
-		return this.deps.clientFactory?.(clientOptions) ?? new AcpClient(clientOptions);
+		task.then(remove, remove);
+		return task;
+	}
+	queueSessionTask(recordId, run, cancel) {
+		const tasks = this.sessionTasks.get(recordId) ?? /* @__PURE__ */ new Set();
+		this.sessionTasks.set(recordId, tasks);
+		const previous = [...tasks].at(-1)?.completion;
+		const result = (async () => {
+			await previous?.catch(() => {});
+			return await run();
+		})();
+		const task = {
+			completion: result.then(() => {}),
+			cancel
+		};
+		task.completion.catch(() => {});
+		tasks.add(task);
+		const remove = () => {
+			tasks.delete(task);
+			if (tasks.size === 0) this.sessionTasks.delete(recordId);
+		};
+		result.then(remove, remove);
+		return this.trackTask(result);
+	}
+	async cancelSessionTasks(recordId) {
+		const tasks = [...this.sessionTasks.get(recordId) ?? []];
+		await Promise.all(tasks.flatMap((task) => task.cancel ? [task.cancel()] : []));
+		return tasks;
+	}
+	async closeClient(client) {
+		await client.close();
+		this.liveClients.delete(client);
 	}
 	createSessionOwner(input) {
 		const owner = {
@@ -900,12 +1124,27 @@ var AcpRuntimeManager = class {
 	}
 	async stopSessionOwner(owner) {
 		await this.flushSessionOwner(owner).catch(() => {});
-		await owner.client.close().catch(() => {});
+		await this.closeClient(owner.client).catch(() => {
+			this.retiringSessionOwners.add(owner);
+		});
 		await owner.projection?.checkpoint.flush().catch(() => {});
 		try {
 			owner.client.clearEventHandlers();
 		} catch {}
 	}
+	async retrySessionCleanup(recordId) {
+		for (const owner of this.retiringSessionOwners) if (owner.recordId === recordId) {
+			owner.retirement ??= this.finalizeSessionConnection({
+				client: owner.client,
+				owner
+			}).then(() => {
+				this.retiringSessionOwners.delete(owner);
+			}).finally(() => {
+				owner.retirement = void 0;
+			});
+			await owner.retirement;
+		}
+	}
 	async refreshClosedState(record) {
 		if (!this.closingActiveRecords.has(record.acpxRecordId)) return record.closed === true;
 		const latest = await this.options.sessionStore.load(record.acpxRecordId).catch(() => void 0);
@@ -933,10 +1172,23 @@ var AcpRuntimeManager = class {
 		return true;
 	}
 	canRetainPersistentSessionOwner(owner, record) {
-		return owner.mode === "persistent" && !record.closed && !(owner.client.hasUnresolvedPrompt?.() ?? false) && owner.client.hasReusableSession(record.acpSessionId);
+		return !this.shuttingDown && owner.mode === "persistent" && !record.closed && !(owner.client.hasUnresolvedPrompt?.() ?? false) && owner.client.hasReusableSession(record.acpSessionId);
+	}
+	resolveMcpServers(session) {
+		const servers = this.options.mcpServers;
+		const { sessionKey, cwd, agentCommand, agentArgv } = session;
+		return [...typeof servers === "function" ? servers({
+			sessionKey,
+			cwd,
+			agentCommand,
+			agentArgv: agentArgv ? [...agentArgv] : void 0
+		}) : servers ?? []];
 	}
-	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption) {
+	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption, authority) {
+		await this.retrySessionCleanup(record.acpxRecordId);
+		assertControlAuthority(authority);
 		const owner = await this.readRetainedSessionOwner(record, { consume: false });
+		assertControlAuthority(authority);
 		if (owner) {
 			const ownedRecord = owner.projection?.record ?? record;
 			try {
@@ -954,34 +1206,43 @@ var AcpRuntimeManager = class {
 				await this.flushSessionOwner(owner);
 			}
 		}
-		const result = await withConnectedSession({
-			sessionRecordId: record.acpxRecordId,
-			loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
-			saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
-			createClient: (options) => this.createClient({
-				...options,
-				processLifecycle: this.options.processLifecycle,
-				processLaunchScope: {
-					kind: "runtime-session",
+		let controlClient;
+		try {
+			const result = await withConnectedSession({
+				sessionRecordId: record.acpxRecordId,
+				loadRecord: async (sessionRecordId) => await this.requireRecord(sessionRecordId),
+				saveRecord: async (connectedRecord) => await this.options.sessionStore.save(connectedRecord),
+				createClient: (options) => controlClient = this.createClient({
+					...options,
+					processLifecycle: this.options.processLifecycle,
+					processLaunchScope: {
+						kind: "runtime-session",
+						sessionKey: record.name ?? record.acpxRecordId
+					}
+				}),
+				mcpServers: this.resolveMcpServers({
+					...record,
 					sessionKey: record.name ?? record.acpxRecordId
-				}
-			}),
-			mcpServers: [...this.options.mcpServers ?? []],
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
-			elicitationModes: this.options.elicitationModes,
-			verbose: this.options.verbose,
-			timeoutMs: this.options.timeoutMs,
-			resumePolicy: resumePolicyForSessionMode(sessionMode),
-			replacingConfigOption,
-			run
-		});
-		return {
-			value: result.value,
-			record: result.record
-		};
+				}),
+				permissionMode: this.options.permissionMode,
+				nonInteractivePermissions: this.options.nonInteractivePermissions,
+				permissionPolicy: this.options.permissionPolicy,
+				onPermissionRequest: this.options.onPermissionRequest,
+				elicitationModes: this.options.elicitationModes,
+				verbose: this.options.verbose,
+				timeoutMs: this.options.timeoutMs,
+				resumePolicy: resumePolicyForSessionMode(sessionMode),
+				replacingConfigOption,
+				authority,
+				run
+			});
+			return {
+				value: result.value,
+				record: result.record
+			};
+		} finally {
+			if (controlClient) this.liveClients.delete(controlClient);
+		}
 	}
 	refreshOwnedRecordLifecycle(owner, record) {
 		record.lastUsedAt = isoNow();
@@ -998,7 +1259,9 @@ var AcpRuntimeManager = class {
 		const key = `${input.mode}\0${input.sessionKey}`;
 		return await this.withManagerLock(this.ensureSessionLocks, key, run);
 	}
-	async withManagerLock(locks, key, run) {
+	async withManagerLock(locks, key, run, authority) {
+		this.assertOpen();
+		assertControlAuthority(authority);
 		const previous = locks.get(key) ?? Promise.resolve();
 		let release;
 		const gate = new Promise((resolve) => {
@@ -1008,6 +1271,8 @@ var AcpRuntimeManager = class {
 		locks.set(key, tail);
 		await previous;
 		try {
+			this.assertOpen();
+			assertControlAuthority(authority);
 			return await run();
 		} finally {
 			release();
@@ -1030,7 +1295,8 @@ var AcpRuntimeManager = class {
 	async loadExistingRuntimeSession(input) {
 		const existingRecordId = input.mode === "persistent" ? input.sessionKey : this.pendingOneShotRecordIds.get(input.sessionKey);
 		if (!existingRecordId) return;
-		let record = await this.options.sessionStore.load(existingRecordId);
+		await this.retrySessionCleanup(existingRecordId);
+		let record = await this.findSession(existingRecordId);
 		if (!record) return;
 		const owner = this.retainedSessionOwners.get(record.acpxRecordId);
 		if (owner) {
@@ -1042,6 +1308,9 @@ var AcpRuntimeManager = class {
 			owner
 		};
 	}
+	async findSession(sessionKey) {
+		return await this.options.sessionStore.load(sessionKey);
+	}
 	canReuseRuntimeSession(input, agent, existing) {
 		if (!shouldReuseExistingRecord(existing.record, {
 			cwd: agent.cwd,
@@ -1068,7 +1337,10 @@ var AcpRuntimeManager = class {
 			agentCommand,
 			agentArgv,
 			cwd,
-			mcpServers: [...this.options.mcpServers ?? []],
+			mcpServers: this.resolveMcpServers({
+				...agent,
+				sessionKey: input.sessionKey
+			}),
 			permissionMode: this.options.permissionMode,
 			nonInteractivePermissions: this.options.nonInteractivePermissions,
 			permissionPolicy: this.options.permissionPolicy,
@@ -1090,6 +1362,7 @@ var AcpRuntimeManager = class {
 		let retained = false;
 		try {
 			await client.start();
+			this.assertOpen();
 			const session = await createOrLoadRuntimeSession(client, input.resumeSessionId, cwd);
 			const record = await this.prepareInitialRuntimeRecord({
 				input,
@@ -1107,15 +1380,15 @@ var AcpRuntimeManager = class {
 			if (!retained) {
 				owner.recordId = void 0;
 				client.clearEventHandlers();
-				await client.close();
+				await this.closeClient(client);
 			}
 		}
 	}
 	async prepareInitialRuntimeRecord(params) {
 		const { input, client, owner, agentCommand, agentArgv, cwd, session } = params;
-		const record = createInitialRecord({
+		const record = createInitialSessionRecord({
 			recordId: createRecordId(input.sessionKey, input.mode),
-			sessionName: input.sessionKey,
+			name: input.sessionKey,
 			sessionId: session.sessionId,
 			agentCommand,
 			agentArgv,
@@ -1135,9 +1408,7 @@ var AcpRuntimeManager = class {
 			agentCommand,
 			timeoutMs: this.options.timeoutMs
 		});
-		applyConfigOptionsToRecord(record, modelApplication.response);
-		syncAdvertisedModelState(record, modelApplication.response ? modelStateFromConfigOptions(modelApplication.response.configOptions) : session.sessionResult.models);
-		if (modelApplication.applied) setCurrentModelId(record, currentModelIdFromSetModelResponse(modelApplication.response, input.sessionOptions?.model));
+		applyInitialModelSelection(record, session.sessionResult.models, input.sessionOptions?.model, modelApplication);
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		persistSessionOptions(record, input.sessionOptions);
 		return record;
@@ -1145,6 +1416,7 @@ var AcpRuntimeManager = class {
 	async retainInitializedSessionOwner(owner, record) {
 		owner.recordId = record.acpxRecordId;
 		await owner.projection?.checkpoint.checkpoint();
+		this.assertOpen();
 		const previousOwner = this.retainedSessionOwners.get(record.acpxRecordId);
 		this.retainedSessionOwners.set(record.acpxRecordId, owner);
 		if (owner.mode === "oneshot") this.pendingOneShotRecordIds.set(owner.sessionKey, record.acpxRecordId);
@@ -1154,11 +1426,12 @@ var AcpRuntimeManager = class {
 		}
 	}
 	startTurn(input) {
+		this.assertOpen();
 		let promptInput;
 		try {
 			promptInput = toPromptInput(input.text, input.attachments);
 		} catch (error) {
-			this.closeRetainedOneShotHandle(input.handle).catch(() => {});
+			this.trackTask(this.closeRetainedOneShotHandle(input.handle).catch(() => {}));
 			throw error;
 		}
 		const queue = new AsyncEventQueue();
@@ -1194,28 +1467,8 @@ var AcpRuntimeManager = class {
 		const abortHandler = () => {
 			requestCancel();
 		};
-		if (input.signal) {
-			if (input.signal.aborted) {
-				promptStarted.reject(/* @__PURE__ */ new Error("ACP turn cancelled before prompt submission."));
-				closeStream();
-				this.closeRetainedOneShotHandle(input.handle).catch(() => {}).then(() => {
-					settleResult({
-						status: "cancelled",
-						stopReason: "cancelled"
-					});
-				});
-				return {
-					requestId: input.requestId,
-					promptStarted: promptStarted.promise,
-					events: queue.iterate(),
-					result: result.promise,
-					cancel: async () => {},
-					closeStream: async () => {}
-				};
-			}
-			input.signal.addEventListener("abort", abortHandler, { once: true });
-		}
-		this.runRuntimeTurnTask({
+		if (input.signal && !input.signal.aborted) input.signal.addEventListener("abort", abortHandler, { once: true });
+		this.queueSessionTask(input.handle.acpxRecordId ?? input.handle.sessionKey, async () => this.runRuntimeTurnTask({
 			input,
 			promptInput,
 			queue,
@@ -1224,7 +1477,7 @@ var AcpRuntimeManager = class {
 			state,
 			settleResult,
 			abortHandler
-		});
+		}), requestCancel);
 		return {
 			requestId: input.requestId,
 			promptStarted: promptStarted.promise,
@@ -1246,30 +1499,39 @@ var AcpRuntimeManager = class {
 		let turn;
 		let terminalResult;
 		try {
-			turn = await this.prepareRuntimeTurn(task);
-			const { sessionId, resumed, loadError } = await this.connectRuntimeTurn(task, turn);
-			await this.resolveRuntimeTurnReady(task, turn, resumed, loadError);
-			if (this.cancelRuntimeTurnBeforePrompt(task)) terminalResult = {
-				status: "cancelled",
-				stopReason: "cancelled"
-			};
-			else {
-				await this.applyPendingRuntimeTurnCancel(task, turn);
-				const response = await this.runRuntimePrompt(task, turn, sessionId);
-				await this.saveCompletedRuntimeTurn(turn, response.stopReason);
+			if (this.cancelRuntimeTurnBeforePrompt(task)) {
+				await this.closeRetainedOneShotHandle(task.input.handle);
 				terminalResult = {
-					status: response.stopReason === "cancelled" ? "cancelled" : "completed",
-					...response.stopReason ? { stopReason: response.stopReason } : {},
-					...response._meta === void 0 ? {} : { _meta: response._meta }
+					status: "cancelled",
+					stopReason: "cancelled"
+				};
+			} else {
+				turn = await this.prepareRuntimeTurn(task);
+				const { sessionId } = await this.connectRuntimeTurn(task, turn);
+				this.assertOpen();
+				await this.resolveRuntimeTurnReady(task, turn);
+				if (this.cancelRuntimeTurnBeforePrompt(task)) terminalResult = {
+					status: "cancelled",
+					stopReason: "cancelled"
 				};
+				else {
+					await this.applyPendingRuntimeTurnCancel(task, turn);
+					const response = await this.runRuntimePrompt(task, turn, sessionId);
+					await this.saveCompletedRuntimeTurn(turn);
+					terminalResult = {
+						status: response.stopReason === "cancelled" ? "cancelled" : "completed",
+						...response.stopReason ? { stopReason: response.stopReason } : {},
+						...response._meta === void 0 ? {} : { _meta: response._meta }
+					};
+				}
 			}
 		} catch (error) {
 			terminalResult = this.failRuntimeTurn(task, error);
 		}
-		try {
-			await this.finalizeRuntimeTurn(task, turn);
-		} catch (error) {
-			terminalResult = this.failRuntimeTurn(task, error);
+		const finalization = await settleAttempt(async () => this.finalizeRuntimeTurn(task, turn));
+		if (!finalization.ok) {
+			task.settleResult(this.failRuntimeTurn(task, finalization.error));
+			throw finalization.error;
 		}
 		task.settleResult(terminalResult);
 	}
@@ -1283,7 +1545,8 @@ var AcpRuntimeManager = class {
 				conversation: turn.conversation,
 				promptMessageId: turn.promptMessageId,
 				onPromptRequestWritten: () => task.promptStarted.resolve(),
-				onElicitation: task.input.onElicitation
+				onElicitation: task.input.onElicitation,
+				onPermissionRequest: task.input.onPermissionRequest
 			});
 		} finally {
 			turn.client.endPromptElicitation?.(sessionId);
@@ -1291,7 +1554,10 @@ var AcpRuntimeManager = class {
 	}
 	async prepareRuntimeTurn(task) {
 		const recordId = task.input.handle.acpxRecordId ?? task.input.handle.sessionKey;
-		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.prepareRuntimeTurnWithOwnership(task));
+		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => {
+			await this.retrySessionCleanup(recordId);
+			return await this.prepareRuntimeTurnWithOwnership(task);
+		});
 	}
 	async prepareRuntimeTurnWithOwnership(task) {
 		const { record, retainedOwner, conversation, acpxState, promptMessageId } = await this.prepareRuntimeTurnState(task);
@@ -1398,7 +1664,10 @@ var AcpRuntimeManager = class {
 			agentCommand: record.agentCommand,
 			agentArgv: record.agentArgv,
 			cwd: record.cwd,
-			mcpServers: [...this.options.mcpServers ?? []],
+			mcpServers: this.resolveMcpServers({
+				...record,
+				sessionKey: record.name ?? record.acpxRecordId
+			}),
 			permissionMode: this.options.permissionMode,
 			nonInteractivePermissions: this.options.nonInteractivePermissions,
 			permissionPolicy: this.options.permissionPolicy,
@@ -1426,24 +1695,24 @@ var AcpRuntimeManager = class {
 		return {
 			hasActivePrompt: () => turn.client.hasActivePrompt(),
 			requestCancelActivePrompt: async () => await this.requestRuntimeTurnCancel(task, turn),
-			setSessionMode: async (modeId) => {
+			setSessionMode: async (modeId, authority) => {
 				await this.waitForRuntimeControlSession(task, turn);
-				await turn.client.setSessionMode(turn.activeSessionId, modeId);
+				await turn.client.setSessionMode(turn.activeSessionId, modeId, authority);
 				const nextState = cloneSessionAcpxState(turn.acpxState) ?? {};
 				nextState.desired_mode_id = modeId;
 				turn.acpxState = nextState;
 			},
-			setSessionModel: async (modelId) => {
+			setSessionModel: async (modelId, authority) => {
 				await this.waitForRuntimeControlSession(task, turn);
 				const models = advertisedModelState(turn.acpxState);
-				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models);
+				const response = await turn.client.setSessionModel(turn.activeSessionId, modelId, models, authority);
 				turn.acpxState = applyModelSelection(turn.acpxState, modelId, response);
 				return response;
 			},
-			setSessionConfigOption: async (configId, value) => {
-				return (await task.state.activeController.setResolvedSessionConfigOption(configId, value)).response;
+			setSessionConfigOption: async (configId, value, authority) => {
+				return (await task.state.activeController.setResolvedSessionConfigOption(configId, value, authority)).response;
 			},
-			setResolvedSessionConfigOption: async (configId, value) => await this.setRuntimeResolvedSessionConfigOption(task, turn, configId, value)
+			setResolvedSessionConfigOption: async (configId, value, authority) => await this.setRuntimeResolvedSessionConfigOption(task, turn, configId, value, authority)
 		};
 	}
 	async waitForRuntimeControlSession(task, turn) {
@@ -1456,14 +1725,14 @@ var AcpRuntimeManager = class {
 		task.state.pendingCancel = true;
 		return true;
 	}
-	async setRuntimeResolvedSessionConfigOption(task, turn, configId, value) {
+	async setRuntimeResolvedSessionConfigOption(task, turn, configId, value, authority) {
 		await this.waitForRuntimeControlSession(task, turn);
 		const resolvedConfigId = resolveSupportedConfigOptionId({
 			...turn.record,
 			acpx: turn.acpxState ?? void 0
 		}, configId);
 		const modelConfigId = advertisedModelState(turn.acpxState)?.configId;
-		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value);
+		const response = await turn.client.setSessionConfigOption(turn.activeSessionId, resolvedConfigId, value, authority);
 		turn.acpxState = applyConfigOptionSelection(turn.acpxState, resolvedConfigId, value, response, modelConfigId);
 		return {
 			configId: resolvedConfigId,
@@ -1506,7 +1775,7 @@ var AcpRuntimeManager = class {
 		const controller = task.state.activeController;
 		if (controller) this.activeControllers.set(turn.record.acpxRecordId, controller);
 	}
-	async resolveRuntimeTurnReady(task, turn, resumed, loadError) {
+	async resolveRuntimeTurnReady(task, turn) {
 		task.sessionReady.resolve();
 		turn.record.lastRequestId = task.input.requestId;
 		turn.record.lastPromptAt = isoNow();
@@ -1514,14 +1783,6 @@ var AcpRuntimeManager = class {
 		turn.record.closedAt = void 0;
 		turn.record.lastUsedAt = isoNow();
 		await turn.liveCheckpoint.checkpoint();
-		this.emitRuntimeTurnLoadStatus(task, resumed, loadError);
-	}
-	emitRuntimeTurnLoadStatus(task, resumed, loadError) {
-		if (!resumed && !loadError) return;
-		this.emitRuntimeTurnEvent(task, {
-			type: "status",
-			text: loadError ? `session reconnect fallback: ${loadError}` : "session resumed"
-		});
 	}
 	cancelRuntimeTurnBeforePrompt(task) {
 		if (!task.state.pendingCancel && !task.input.signal?.aborted) return false;
@@ -1535,7 +1796,7 @@ var AcpRuntimeManager = class {
 		if (cancelled) task.state.pendingCancel = false;
 		return cancelled;
 	}
-	async saveCompletedRuntimeTurn(turn, _stopReason) {
+	async saveCompletedRuntimeTurn(turn) {
 		turn.record.acpSessionId = turn.activeSessionId;
 		reconcileAgentSessionId(turn.record, turn.record.agentSessionId);
 		turn.record.protocolVersion = turn.client.initializeResult?.protocolVersion;
@@ -1583,8 +1844,11 @@ var AcpRuntimeManager = class {
 	async closeRuntimeTurnClient(turn, pooled) {
 		if (!turn || pooled) return;
 		turn.owner.activeTurn = void 0;
-		const failure = firstFailedAttempt([await settleAttempt(() => turn.client.clearEventHandlers()), await settleAttempt(async () => turn.client.close())]);
-		if (failure) throw failure.error;
+		const failure = firstFailedAttempt([await settleAttempt(() => turn.client.clearEventHandlers()), await settleAttempt(async () => this.closeClient(turn.client))]);
+		if (failure) {
+			this.retiringSessionOwners.add(turn.owner);
+			throw failure.error;
+		}
 	}
 	cleanupRuntimeTurn(task, turn) {
 		if (turn) {
@@ -1615,51 +1879,62 @@ var AcpRuntimeManager = class {
 		yield* turn.events;
 		yield legacyTerminalEventFromTurnResult(await turn.result);
 	}
-	async getStatus(handle) {
+	getStatus(handle) {
+		this.assertOpen();
+		return this.trackTask(this.readStatus(handle));
+	}
+	async readStatus(handle) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
 		const owner = this.retainedSessionOwners.get(recordId);
 		if (owner) await this.flushSessionOwner(owner);
-		const record = await this.requireRecord(recordId);
-		return {
-			summary: statusSummary(record),
-			acpxRecordId: record.acpxRecordId,
-			backendSessionId: record.acpSessionId,
-			agentSessionId: record.agentSessionId,
-			...buildModelsField(record),
-			...buildUsageField(record),
-			...buildAvailableCommandsField(record),
-			details: {
-				cwd: record.cwd,
-				lastUsedAt: record.lastUsedAt,
-				closed: record.closed === true,
-				...record.acpx?.config_options !== void 0 ? { configOptions: structuredClone(record.acpx.config_options) } : {}
-			}
-		};
+		return runtimeStatusFromRecord(await this.requireRecord(recordId));
 	}
-	async setMode(handle, mode, sessionMode = "persistent") {
+	async setMode(handle, mode, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModeWithOwnership(handle, mode, sessionMode));
+		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModeWithOwnership(handle, mode, sessionMode, authority), authority);
 	}
-	async setModeWithOwnership(handle, mode, sessionMode) {
+	async setModeWithOwnership(handle, mode, sessionMode, authority) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		let targetRecord = record;
-		if (controller) await controller.setSessionMode(mode);
+		if (controller) await controller.setSessionMode(mode, authority);
 		else targetRecord = (await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId }) => {
-			await client.setSessionMode(sessionId, mode);
-		})).record;
+			await client.setSessionMode(sessionId, mode, authority);
+		}, void 0, authority)).record;
 		setDesiredModeId(targetRecord, mode);
 		await this.options.sessionStore.save(targetRecord);
 	}
-	async setConfigOption(handle, key, value, sessionMode = "persistent") {
+	async setModel(handle, model, sessionMode = "persistent", authority) {
+		const recordId = handle.acpxRecordId ?? handle.sessionKey;
+		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModelWithOwnership(handle, model, sessionMode, authority), authority);
+	}
+	async setModelWithOwnership(handle, model, sessionMode, authority) {
+		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		assertControlAuthority(authority);
+		const controller = this.activeControllers.get(record.acpxRecordId);
+		if (controller) {
+			const response = await controller.setSessionModel(model, authority);
+			record.acpx = applyModelSelection(record.acpx, model, response);
+			await this.options.sessionStore.save(record);
+			return;
+		}
+		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
+			const response = await client.setSessionModel(sessionId, model, advertisedModelState(connectedRecord.acpx), authority);
+			connectedRecord.acpx = applyModelSelection(connectedRecord.acpx, model, response);
+		}, { key: "model" }, authority);
+		await this.options.sessionStore.save(result.record);
+	}
+	async setConfigOption(handle, key, value, sessionMode = "persistent", authority) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
-		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setConfigOptionWithOwnership(handle, key, value, sessionMode));
+		return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setConfigOptionWithOwnership(handle, key, value, sessionMode, authority), authority);
 	}
-	async setConfigOptionWithOwnership(handle, key, value, sessionMode) {
+	async setConfigOptionWithOwnership(handle, key, value, sessionMode, authority) {
 		const record = await this.requireRecord(handle.acpxRecordId ?? handle.sessionKey);
+		assertControlAuthority(authority);
 		const controller = this.activeControllers.get(record.acpxRecordId);
 		if (controller) {
-			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value);
+			const { configId, response } = await controller.setResolvedSessionConfigOption(key, value, authority);
 			record.acpx = applyConfigOptionSelection(record.acpx, configId, value, response);
 			await this.options.sessionStore.save(record);
 			return response;
@@ -1667,25 +1942,44 @@ var AcpRuntimeManager = class {
 		const result = await this.withRuntimeControlSession(record, sessionMode, async ({ client, sessionId, record: connectedRecord }) => {
 			const configId = resolveSupportedConfigOptionId(connectedRecord, key);
 			const modelConfigId = advertisedModelState(connectedRecord.acpx)?.configId;
-			const response = await client.setSessionConfigOption(sessionId, configId, value);
+			const response = await client.setSessionConfigOption(sessionId, configId, value, authority);
 			connectedRecord.acpx = applyConfigOptionSelection(connectedRecord.acpx, configId, value, response, modelConfigId);
 			return response;
 		}, {
 			key,
 			resolve: (connectedRecord) => resolveSupportedConfigOptionId(connectedRecord, key)
-		});
+		}, authority);
 		await this.options.sessionStore.save(result.record);
 		return result.value;
 	}
 	async cancel(handle) {
 		await this.activeControllers.get(handle.acpxRecordId ?? handle.sessionKey)?.requestCancelActivePrompt();
 	}
-	async close(handle, options = {}) {
+	prepareFreshSession(handle) {
+		this.assertOpen();
+		const recordId = handle.acpxRecordId ?? handle.sessionKey;
+		const cancelled = this.cancelSessionTasks(recordId);
+		cancelled.catch(() => {});
+		return this.queueSessionTask(recordId, async () => {
+			const tasks = await cancelled;
+			await Promise.all(tasks.map((task) => task.completion));
+			return await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.closeRuntimeSession(handle, "prepare-fresh"));
+		});
+	}
+	close(handle, options = {}) {
+		this.assertOpen();
+		const recordId = handle.acpxRecordId ?? handle.sessionKey;
+		return this.trackTask(this.withManagerLock(this.runtimeOperationLocks, recordId, async () => {
+			return await this.closeRuntimeSession(handle, options.discardPersistentState === true ? "discard" : "release");
+		}));
+	}
+	async closeRuntimeSession(handle, intent) {
 		const recordId = handle.acpxRecordId ?? handle.sessionKey;
+		await this.retrySessionCleanup(recordId);
 		const record = await this.resolveRuntimeRecordForClose(recordId);
 		this.markActiveRuntimeRecordClosing(record);
-		await this.cancel(handle);
-		await this.closeRuntimeRecordOwnership(record, options.discardPersistentState === true);
+		if (intent !== "prepare-fresh") await this.cancelSessionTasks(recordId);
+		await this.closeRuntimeRecordOwnership(record, intent);
 		record.closed = true;
 		record.closedAt = isoNow();
 		await this.options.sessionStore.save(record);
@@ -1698,14 +1992,20 @@ var AcpRuntimeManager = class {
 	markActiveRuntimeRecordClosing(record) {
 		if (this.activeControllers.has(record.acpxRecordId)) this.closingActiveRecords.add(record.acpxRecordId);
 	}
-	async closeRuntimeRecordOwnership(record, discardPersistentState) {
-		if (discardPersistentState) {
-			await this.closeBackendSession(record);
-			record.acpx = {
-				...record.acpx,
-				reset_on_next_ensure: true
-			};
+	async closeRuntimeRecordOwnership(record, intent) {
+		if (intent === "discard") await this.closeBackendSession(record);
+		else if (intent === "prepare-fresh") {
+			const owner = this.retainedSessionOwners.get(record.acpxRecordId);
+			if (owner) {
+				this.removeRetainedSessionOwner(owner);
+				this.retiringSessionOwners.add(owner);
+			}
+			await this.retrySessionCleanup(record.acpxRecordId);
 		} else await this.closeRetainedSessionOwner(record.acpxRecordId);
+		if (intent !== "release") record.acpx = {
+			...record.acpx,
+			reset_on_next_ensure: true
+		};
 	}
 	async closeBackendSession(record) {
 		const connection = await this.acquireBackendCloseConnection(record);
@@ -1714,16 +2014,16 @@ var AcpRuntimeManager = class {
 		} catch (error) {
 			this.handleBackendSessionCloseError(record, error);
 		} finally {
-			await this.finalizeBackendCloseConnection(connection);
+			await this.finalizeSessionConnection(connection);
 		}
 	}
-	async finalizeBackendCloseConnection(connection) {
+	async finalizeSessionConnection(connection) {
 		const failure = firstFailedAttempt([
 			await settleAttempt(async () => {
 				if (connection.owner) await this.flushSessionOwner(connection.owner);
 			}),
 			await settleAttempt(() => connection.owner?.client.clearEventHandlers()),
-			await settleAttempt(async () => connection.client.close())
+			await settleAttempt(async () => this.closeClient(connection.client))
 		]);
 		if (failure) throw failure.error;
 	}
@@ -1733,23 +2033,7 @@ var AcpRuntimeManager = class {
 			client: owner.client,
 			owner
 		};
-		return { client: this.createClient({
-			agentCommand: record.agentCommand,
-			agentArgv: record.agentArgv,
-			cwd: record.cwd,
-			mcpServers: [...this.options.mcpServers ?? []],
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
-			elicitationModes: this.options.elicitationModes,
-			processLifecycle: this.options.processLifecycle,
-			processLaunchScope: {
-				kind: "runtime-session",
-				sessionKey: record.name ?? record.acpxRecordId
-			},
-			verbose: this.options.verbose
-		}) };
+		return { client: this.createTurnClient(record) };
 	}
 	async requestBackendSessionClose(record, connection) {
 		if (!connection.owner) await withTimeout(connection.client.start(), this.options.timeoutMs);
@@ -1784,7 +2068,10 @@ var FileSessionStore = class {
 		return path.join(this.sessionDir, `${safeSessionId(sessionId)}.json`);
 	}
 	async ensureDir() {
-		await fs.mkdir(this.sessionDir, { recursive: true });
+		await fs.mkdir(this.sessionDir, {
+			recursive: true,
+			mode: 448
+		});
 	}
 	async load(sessionId) {
 		await this.ensureDir();
@@ -1804,14 +2091,9 @@ var FileSessionStore = class {
 		return parseSessionRecord(parsed) ?? void 0;
 	}
 	async save(record) {
-		await this.ensureDir();
 		const persisted = serializeSessionRecordForDisk(record);
 		assertPersistedKeyPolicy(persisted);
-		const file = this.filePath(record.acpxRecordId);
-		const tempFile = createAtomicWriteTempPath(file);
-		const payload = JSON.stringify(persisted, null, 2);
-		await fs.writeFile(tempFile, `${payload}\n`, "utf8");
-		await fs.rename(tempFile, file);
+		await writePrivateJsonFile(this.filePath(record.acpxRecordId), persisted);
 	}
 };
 function createFileSessionStore(options) {
@@ -1856,125 +2138,246 @@ function writeHandleState(handle, state) {
 	handle.agentSessionId = state.agentSessionId;
 }
 //#endregion
-//#region src/runtime/public/probe.ts
-function isPrimitiveDetail(value) {
-	return value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
+//#region src/runtime/shared.ts
+const SHARED_BACKEND = "acpx-shared";
+function invalidOption(message) {
+	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", message);
 }
-function formatFunctionDetail(value) {
-	return value.name ? `[Function ${value.name}]` : "[Function]";
+function sharedHandle(record) {
+	return {
+		backend: SHARED_BACKEND,
+		sessionKey: record.name ?? "",
+		runtimeSessionName: record.acpxRecordId,
+		acpxRecordId: record.acpxRecordId,
+		backendSessionId: record.acpSessionId,
+		agentSessionId: record.agentSessionId,
+		cwd: record.cwd
+	};
 }
-function serializeRuntimeDetail(value) {
-	const seen = /* @__PURE__ */ new WeakSet();
-	return JSON.stringify(value, (_key, nested) => {
-		if (nested instanceof Error) return nested.message || nested.name;
-		if (nested && typeof nested === "object") {
-			if (seen.has(nested)) return "[Circular]";
-			seen.add(nested);
+function sharedRecordId(handle) {
+	if (handle.backend !== SHARED_BACKEND || !handle.acpxRecordId) return invalidOption("A shared runtime requires a handle from a shared session.");
+	return handle.acpxRecordId;
+}
+function turnFailure(error) {
+	const normalized = normalizeOutputError(error, {
+		defaultCode: "RUNTIME",
+		origin: "queue"
+	});
+	if (normalized.detailCode === "QUEUE_REQUEST_CANCELLED") return {
+		status: "cancelled",
+		stopReason: "cancelled"
+	};
+	return {
+		status: "failed",
+		error: {
+			message: normalized.message,
+			code: normalized.code,
+			detailCode: normalized.detailCode,
+			retryable: normalized.retryable
 		}
-		return nested;
-	}) ?? "undefined";
+	};
 }
-function formatRuntimeDetail(value) {
-	if (value instanceof Error) return value.message || value.name;
-	if (typeof value === "string") return value;
-	if (isPrimitiveDetail(value)) return String(value);
-	if (typeof value === "function") return formatFunctionDetail(value);
-	try {
-		return serializeRuntimeDetail(value);
-	} catch {
-		return "unserializable object";
+/** A client of the CLI's local session owner. Shutdown detaches this client. */
+var SharedAcpRuntime = class {
+	registry;
+	options;
+	disconnect = new AbortController();
+	pending = /* @__PURE__ */ new Set();
+	constructor(options) {
+		for (const name of [
+			"sessionStore",
+			"agentProcessEnv",
+			"mcpServers",
+			"processLifecycle",
+			"onPermissionRequest",
+			"elicitationModes"
+		]) if (Object.hasOwn(options, name)) invalidOption(`${name} belongs to the in-process runtime and is not supported by shared sessions.`);
+		this.options = {
+			...options,
+			cwd: path.resolve(options.cwd),
+			authCredentials: options.authCredentials ? { ...options.authCredentials } : void 0
+		};
+		this.registry = options.agentRegistry ?? createAgentRegistry();
 	}
-}
-function normalizeRuntimeDetails(details) {
-	return details?.map((detail) => formatRuntimeDetail(detail));
-}
-async function probeRuntime(options, deps = {}) {
-	const agentName = options.probeAgent?.trim() || "codex";
-	const agentCommand = normalizeAgentCommandInput(options.agentRegistry.resolve(agentName));
-	const client = createProbeClient(options, agentName, agentCommand, deps);
-	try {
-		await client.start();
+	assertOpen() {
+		if (this.disconnect.signal.aborted) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "Shared ACP runtime is shut down.");
+	}
+	track(task) {
+		this.pending.add(task);
+		task.then(() => this.pending.delete(task), () => this.pending.delete(task));
+		return task;
+	}
+	sessionOptions(input) {
+		if (!input.agent.trim()) invalidOption("ACP agent id is required.");
 		return {
-			ok: true,
-			message: "embedded ACP runtime ready",
-			details: [
-				`agent=${agentName}`,
-				`command=${agentCommand.agentCommand}`,
-				`cwd=${options.cwd}`,
-				...client.initializeResult?.protocolVersion ? [`protocolVersion=${client.initializeResult.protocolVersion}`] : []
-			]
+			...normalizeAgentCommandInput(this.registry.resolve(input.agent)),
+			cwd: path.resolve(input.cwd ?? this.options.cwd),
+			name: input.sessionKey.trim() || void 0
 		};
-	} catch (error) {
+	}
+	async findSession(input) {
+		this.assertOpen();
+		const record = await findSession(this.sessionOptions(input));
+		return record ? sharedHandle(record) : void 0;
+	}
+	ensureSession(input) {
+		this.assertOpen();
+		if (input.mode !== "persistent") invalidOption("Shared sessions require persistent mode; use the in-process runtime for oneshot sessions.");
+		const session = this.sessionOptions(input);
+		return this.track(ensureSession({
+			...this.options,
+			...session,
+			walkBoundary: session.cwd,
+			sessionOptions: input.sessionOptions,
+			resumeSessionId: input.resumeSessionId,
+			handleProcessInterrupts: false,
+			signal: this.disconnect.signal
+		}).then(({ record }) => {
+			this.assertOpen();
+			return sharedHandle(record);
+		}));
+	}
+	startTurn(input) {
+		this.assertOpen();
+		if (input.mode !== "prompt" || input.onPermissionRequest || input.onElicitation) invalidOption("Shared turns support prompt mode and the client's static permission policy; in-process callbacks and steering are unsupported.");
+		if (!input.requestId.trim()) invalidOption("A shared turn requires a requestId.");
+		const sessionId = sharedRecordId(input.handle);
+		const prompt = toPromptInput(input.text, input.attachments);
+		const events = new AsyncEventQueue();
+		const promptStarted = createDeferred();
+		promptStarted.promise.catch(() => {});
+		let accepted = false;
+		let settled = false;
+		let cancelRequested = input.signal?.aborted === true;
+		let cancellation;
+		const cancel = async () => {
+			cancelRequested = true;
+			if (!accepted || settled) return;
+			cancellation ??= tryCancelOnRunningOwner({
+				sessionId,
+				targetRequestId: input.requestId
+			}).then(() => {});
+			await cancellation;
+		};
+		const onAbort = () => {
+			cancel().catch(() => {});
+		};
+		input.signal?.addEventListener("abort", onAbort, { once: true });
+		const run = async () => {
+			if (cancelRequested) return {
+				status: "cancelled",
+				stopReason: "cancelled"
+			};
+			if ((await resolveSessionRecord(sessionId)).closed) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "Shared session is closed; ensure it again before submitting a turn.");
+			if (cancelRequested) return {
+				status: "cancelled",
+				stopReason: "cancelled"
+			};
+			const result = await sendSession({
+				...this.options,
+				sessionId,
+				requestId: input.requestId,
+				prompt: typeof prompt === "string" ? textPrompt(prompt) : prompt,
+				resumePolicy: "same-session-only",
+				requireSharedRuntime: true,
+				signal: this.disconnect.signal,
+				timeoutMs: input.timeoutMs ?? this.options.timeoutMs,
+				queueOwnerArgs: [fileURLToPath(import.meta.resolve("acpx/dist/cli.js")), "__queue-owner"],
+				onQueueAccepted: () => {
+					accepted = true;
+					if (cancelRequested) cancel().catch(() => {});
+				},
+				onPromptStarted: () => promptStarted.resolve(),
+				outputFormatter: {
+					...DISCARD_OUTPUT_FORMATTER,
+					onAcpMessage: (message) => {
+						const event = parsePromptEventLine(JSON.stringify(message));
+						if (event) events.push(event);
+					}
+				},
+				errorEmissionPolicy: { queueErrorAlreadyEmitted: false },
+				waitForCompletion: true
+			});
+			if ("queued" in result) throw new AcpRuntimeError("ACP_TURN_FAILED", "Shared turn ended without a completion result.");
+			return {
+				status: result.stopReason === "cancelled" ? "cancelled" : "completed",
+				stopReason: result.stopReason,
+				_meta: result._meta
+			};
+		};
+		const result = this.track(run().catch(turnFailure).finally(() => {
+			settled = true;
+			promptStarted.reject(new AcpRuntimeError("ACP_TURN_FAILED", "Turn settled before its prompt was written."));
+			input.signal?.removeEventListener("abort", onAbort);
+			events.close();
+		}));
 		return {
-			ok: false,
-			message: "embedded ACP runtime probe failed",
-			details: [
-				`agent=${agentName}`,
-				`command=${agentCommand.agentCommand}`,
-				`cwd=${options.cwd}`,
-				formatRuntimeDetail(error)
-			]
+			requestId: input.requestId,
+			promptStarted: promptStarted.promise,
+			events: events.iterate(),
+			result,
+			cancel,
+			closeStream: async () => {
+				events.clear();
+				events.close();
+			}
 		};
-	} finally {
-		await client.close().catch(() => {});
 	}
-}
-function createProbeClient(options, agentName, agentCommand, deps) {
-	const clientOptions = {
-		...agentCommand,
-		cwd: options.cwd,
-		agentProcessEnv: options.agentProcessEnv,
-		mcpServers: [...options.mcpServers ?? []],
-		permissionMode: options.permissionMode,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		processLifecycle: options.processLifecycle,
-		processLaunchScope: {
-			kind: "runtime-probe",
-			agent: agentName
-		},
-		verbose: options.verbose
-	};
-	return deps.clientFactory?.(clientOptions) ?? new AcpClient(clientOptions);
+	async *runTurn(input) {
+		const turn = this.startTurn(input);
+		yield* turn.events;
+		yield legacyTerminalEventFromTurnResult(await turn.result);
+	}
+	async getStatus(input) {
+		this.assertOpen();
+		return runtimeStatusFromRecord(await resolveSessionRecord(sharedRecordId(input.handle)));
+	}
+	watchSession(input) {
+		this.assertOpen();
+		const signal = input.signal ? AbortSignal.any([input.signal, this.disconnect.signal]) : this.disconnect.signal;
+		const recordId = sharedRecordId(input.handle);
+		const record = readSessionRecord(recordId).then((value) => {
+			if (!value || value.acpxRecordId !== recordId) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "Shared session record is unavailable.");
+			return value;
+		});
+		record.catch(() => {});
+		return watchSession({
+			record,
+			cursor: input.cursor,
+			signal
+		});
+	}
+	async cancel(input) {
+		this.assertOpen();
+		await this.track(cancelSessionPrompt({ sessionId: sharedRecordId(input.handle) }));
+	}
+	async close(input) {
+		this.assertOpen();
+		await this.track(closeSession(sharedRecordId(input.handle)));
+	}
+	async shutdown() {
+		this.disconnect.abort(new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "Shared client detached; submitted work may still be running."));
+		await Promise.allSettled(this.pending);
+	}
+};
+function createSharedAcpRuntime(options) {
+	return new SharedAcpRuntime(options);
 }
 //#endregion
 //#region src/runtime.ts
 const ACPX_BACKEND_ID = "acpx";
 const ACPX_CAPABILITIES = { controls: [
 	"session/set_mode",
+	"session/set_model",
 	"session/set_config_option",
 	"session/status"
 ] };
-function createAgentRegistry(params) {
-	const overrides = normalizeRegistryOverrides(params?.overrides);
-	return {
-		resolve(agentName) {
-			const normalizedAgentName = normalizeAgentName(agentName);
-			return overrides[normalizedAgentName] ?? overrides[resolveCanonicalAgentName(agentName)] ?? resolveAgentArgv(agentName) ?? resolveAgentCommand(agentName);
-		},
-		list() {
-			return listBuiltInAgents(overrides);
-		}
-	};
-}
-function normalizeRegistryOverrides(values) {
-	const normalized = {};
-	for (const [name, value] of Object.entries(values ?? {})) {
-		const normalizedName = normalizeAgentName(name);
-		if (!normalizedName) continue;
-		const normalizedValue = normalizeRegistryOverride(value);
-		if (normalizedValue) normalized[normalizedName] = normalizedValue;
-	}
-	return normalized;
-}
-function normalizeRegistryOverride(value) {
-	if (typeof value === "string") return value.trim() || void 0;
-	return value.length > 0 && value[0]?.length ? [...value] : void 0;
-}
 var AcpxRuntime = class {
 	options;
 	testOptions;
 	healthy = false;
+	shutdownTask;
+	probeTasks = /* @__PURE__ */ new Set();
 	manager = null;
 	managerPromise = null;
 	constructor(options, testOptions) {
@@ -2002,11 +2405,27 @@ var AcpxRuntime = class {
 			details: normalizeRuntimeDetails(report.details)
 		};
 	}
-	async ensureSession(input) {
+	resolveSessionIdentity(input) {
 		const sessionName = input.sessionKey.trim();
 		if (!sessionName) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "ACP session key is required.");
 		const agent = input.agent.trim();
 		if (!agent) throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", "ACP agent id is required.");
+		return {
+			sessionName,
+			agent
+		};
+	}
+	async findSession(input) {
+		const { sessionName, agent } = this.resolveSessionIdentity(input);
+		const record = await (await this.getManager()).findSession(sessionName);
+		return record ? this.createSessionHandle({
+			sessionKey: input.sessionKey,
+			agent,
+			mode: "persistent"
+		}, record) : void 0;
+	}
+	async ensureSession(input) {
+		const { sessionName, agent } = this.resolveSessionIdentity(input);
 		const record = await (await this.getManager()).ensureSession({
 			sessionKey: sessionName,
 			agent,
@@ -2015,6 +2434,12 @@ var AcpxRuntime = class {
 			resumeSessionId: input.resumeSessionId,
 			sessionOptions: input.sessionOptions
 		});
+		return this.createSessionHandle({
+			...input,
+			agent
+		}, record);
+	}
+	createSessionHandle(input, record) {
 		const handle = {
 			sessionKey: input.sessionKey,
 			backend: ACPX_BACKEND_ID,
@@ -2025,8 +2450,8 @@ var AcpxRuntime = class {
 			agentSessionId: record.agentSessionId
 		};
 		writeHandleState(handle, {
-			name: sessionName,
-			agent,
+			name: input.sessionKey.trim(),
+			agent: input.agent,
 			cwd: record.cwd,
 			mode: input.mode,
 			acpxRecordId: record.acpxRecordId,
@@ -2046,7 +2471,8 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
-			onElicitation: input.onElicitation
+			onElicitation: input.onElicitation,
+			onPermissionRequest: input.onPermissionRequest
 		}));
 		return {
 			requestId: input.requestId,
@@ -2078,7 +2504,8 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
-			onElicitation: input.onElicitation
+			onElicitation: input.onElicitation,
+			onPermissionRequest: input.onPermissionRequest
 		});
 	}
 	async getCapabilities(input) {
@@ -2098,21 +2525,40 @@ var AcpxRuntime = class {
 	}
 	async setMode(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		await (await this.getManager()).setMode(handle, input.mode, state.mode);
+		await (await this.getManager()).setMode(handle, input.mode, state.mode, input);
+	}
+	async setModel(input) {
+		const { handle, state } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).setModel(handle, input.model, state.mode, input);
 	}
 	async setConfigOption(input) {
 		const { handle, state } = this.resolveManagerHandle(input.handle);
-		return await (await this.getManager()).setConfigOption(handle, input.key, input.value, state.mode);
+		return await (await this.getManager()).setConfigOption(handle, input.key, input.value, state.mode, input);
 	}
 	async cancel(input) {
 		const { handle } = this.resolveManagerHandle(input.handle);
 		await (await this.getManager()).cancel(handle);
 	}
+	async prepareFreshSession(input) {
+		const { handle } = this.resolveManagerHandle(input.handle);
+		await (await this.getManager()).prepareFreshSession(handle);
+	}
 	async close(input) {
 		const { handle } = this.resolveManagerHandle(input.handle);
 		await (await this.getManager()).close(handle, { discardPersistentState: input.discardPersistentState });
 	}
+	shutdown() {
+		if (!this.shutdownTask) {
+			this.healthy = false;
+			const managerShutdown = this.managerPromise?.then((manager) => manager.shutdown());
+			this.shutdownTask = Promise.allSettled([managerShutdown, ...this.probeTasks]).then(([manager]) => {
+				if (manager.status === "rejected") throw manager.reason;
+			});
+		}
+		return this.shutdownTask;
+	}
 	async getManager() {
+		if (this.shutdownTask) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
 		if (this.manager) return this.manager;
 		if (!this.managerPromise) this.managerPromise = Promise.resolve(this.testOptions?.managerFactory?.(this.options) ?? new AcpRuntimeManager(this.options)).then((manager) => {
 			this.manager = manager;
@@ -2121,7 +2567,16 @@ var AcpxRuntime = class {
 		return await this.managerPromise;
 	}
 	async runProbe() {
-		return await (this.testOptions?.probeRunner?.(this.options) ?? probeRuntime(this.options));
+		if (this.shutdownTask) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
+		const probe = this.testOptions?.probeRunner?.(this.options) ?? this.getManager().then((manager) => manager.probe());
+		this.probeTasks.add(probe);
+		try {
+			const report = await probe;
+			if (this.shutdownTask) throw new AcpRuntimeError("ACP_BACKEND_UNAVAILABLE", "ACP runtime is shut down.");
+			return report;
+		} finally {
+			this.probeTasks.delete(probe);
+		}
 	}
 	resolveManagerHandle(handle) {
 		const state = this.resolveHandleState(handle);
@@ -2161,6 +2616,6 @@ function createRuntimeStore(options) {
 	return createFileSessionStore(options);
 }
 //#endregion
-export { ACPX_BACKEND_ID, AcpRuntimeError, AcpxRuntime, DEFAULT_AGENT_NAME, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isAcpRuntimeError, isRequestedModelUnsupportedError };
+export { ACPX_BACKEND_ID, AcpRuntimeError, AcpxRuntime, DEFAULT_AGENT_NAME, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, REQUESTED_MODEL_UNSUPPORTED_REASONS, RequestedModelUnsupportedError, SharedAcpRuntime, createAcpRuntime, createAgentRegistry, createFileSessionStore, createRuntimeStore, createSharedAcpRuntime, decodeAcpxRuntimeHandleState, encodeAcpxRuntimeHandleState, isAcpRuntimeError, isRequestedModelUnsupportedError };
 
 //# sourceMappingURL=runtime.js.map