acpx 0.16.0 → 0.17.1

package/dist/runtime.js

@@ -1,5 +1,8 @@
-import { A as isRequestedModelUnsupportedError, C as recordSessionUpdate, D as REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE, Dt as withTimeout, E as AcpClient, L as textPrompt, Mt as extractAcpError, Nt as isAcpResourceNotFoundError, O as REQUESTED_MODEL_UNSUPPORTED_REASONS, S as recordPromptSubmission, T as advertisedModelState, Z as assertPersistedKeyPolicy, _ as reconcileAgentSessionId, a as applyConfigOptionSelection, c as applyModelSelection, f as persistSessionOptions, g as createInitialSessionRecord, gt as writePrivateJsonFile, h as applyLifecycleSnapshotToRecord, i as connectAndLoadSession, jt as normalizeOutputError, k as RequestedModelUnsupportedError, l as applyRequestedModelIfAdvertised, m as applyConversation, n as runPromptTurn, o as applyConfigOptionsToRecord, ot as parseSessionRecord, p as sessionOptionsFromRecord, r as withConnectedSession, s as applyInitialModelSelection, st as serializeSessionRecordForDisk, t as LiveSessionCheckpoint, u as setDesiredModeId, v as cloneSessionAcpxState, w as trimConversationForRuntime, x as recordClientOperation, y as cloneSessionConversation } from "./live-checkpoint-BEfxBKCh.js";
-import { D as normalizeAgentCommandInput, a as createAgentRegistry, i as DEFAULT_AGENT_NAME } from "./agent-registry-DU6mhZBL.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-D2rstexT.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, rt as TimeoutError, s as DISCARD_OUTPUT_FORMATTER, v as closeSession, w as connectAndLoadSession } from "./queue-owner-runtime-Dgv3e2Tp.js";
+import { D as normalizeAgentCommandInput, a as createAgentRegistry, i as DEFAULT_AGENT_NAME } from "./agent-registry-evUoJINz.js";
+import { t as watchSession } from "./watch-DxuXEc8n.js";
+import { fileURLToPath } from "node:url";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
@@ -544,6 +547,61 @@ function updateStatusEvent(payload, tag) {
 }
 //#endregion
 //#region src/runtime/public/probe.ts
+/**
+* Inspect session model metadata without a runtime store or prompt. The agent
+* may create native session history; only its owned transport is closed.
+*/
+async function inspectAgentModels(options) {
+	options.signal?.throwIfAborted();
+	const timeoutMs = options.timeoutMs ?? 12e4;
+	if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647) throw new RangeError("Model inspection timeoutMs must be positive and at most 2147483647");
+	const deadline = new AbortController();
+	const signal = options.signal ? AbortSignal.any([options.signal, deadline.signal]) : deadline.signal;
+	const assertActive = () => signal.throwIfAborted();
+	const client = new AcpClient({
+		...normalizeAgentCommandInput(options.agentCommand),
+		cwd: options.cwd,
+		agentProcessEnv: options.agentProcessEnv,
+		permissionMode: "deny-all",
+		nonInteractivePermissions: "deny",
+		fs: false,
+		terminal: false,
+		processLifecycle: {
+			onBeforeSpawn: assertActive,
+			onSpawned: assertActive
+		}
+	});
+	const timer = setTimeout(() => deadline.abort(new TimeoutError(timeoutMs)), timeoutMs);
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(signal.reason);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	const inspection = (async () => {
+		assertActive();
+		await client.start();
+		assertActive();
+		const { models } = await client.createSession();
+		assertActive();
+		return models ? {
+			currentModelId: models.currentModelId,
+			availableModelIds: models.availableModels.map((model) => model.modelId),
+			availableModels: models.availableModels
+		} : void 0;
+	})();
+	try {
+		return await Promise.race([inspection, aborted]);
+	} finally {
+		clearTimeout(timer);
+		signal.removeEventListener("abort", onAbort);
+		try {
+			if (signal.aborted) await client.close();
+		} finally {
+			await inspection.catch(() => {});
+			await client.close();
+		}
+	}
+}
 function isPrimitiveDetail(value) {
 	return value == null || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol";
 }
@@ -733,7 +791,7 @@ function commandRecord(value) {
 	return value;
 }
 //#endregion
-//#region src/runtime/engine/manager.ts
+//#region src/runtime/engine/turn.ts
 function createDeferred() {
 	let resolve;
 	let reject;
@@ -746,22 +804,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 = [];
@@ -798,17 +840,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 = [];
@@ -837,13 +868,6 @@ function toPromptInput(text, attachments) {
 	}
 	return blocks.length > 0 ? blocks : textPrompt(text);
 }
-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",
@@ -858,6 +882,42 @@ function legacyTerminalEventFromTurnResult(result) {
 		...result._meta === void 0 ? {} : { _meta: result._meta }
 	};
 }
+//#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 firstFailedAttempt(attempts) {
+	return attempts.find((attempt) => !attempt.ok);
+}
+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 createRecordId(sessionKey, mode) {
+	if (mode === "persistent") return sessionKey;
+	return `${sessionKey}:oneshot:${randomUUID()}`;
+}
+function resumePolicyForSessionMode(mode) {
+	return mode === "persistent" ? "same-session-only" : "allow-new";
+}
 function advertisedConfigOptionIds(record) {
 	const configOptions = record.acpx?.config_options;
 	if (!configOptions) return;
@@ -872,6 +932,14 @@ function resolveSupportedConfigOptionId(record, configId) {
 	const supportedText = supported.length > 0 ? supported.join(", ") : "none";
 	throw new AcpRuntimeError("ACP_BACKEND_UNSUPPORTED_CONTROL", `ACP session ${record.acpxRecordId} does not advertise config option '${configId}'. Supported config options: ${supportedText}.`);
 }
+async function startRuntimeClient(client, agent, timeoutMs) {
+	try {
+		await withTimeout(client.start(), timeoutMs);
+	} catch (error) {
+		if (!(error instanceof TimeoutError)) throw error;
+		throw new AcpRuntimeError("ACP_SESSION_INIT_FAILED", `ACP agent ${path.basename(agent.agentArgv?.[0] ?? agent.agentCommand.split(/\s+/)[0])} did not complete ACP initialization within ${timeoutMs}ms. Check that the configured command starts an ACP server.`, { cause: error });
+	}
+}
 async function createOrLoadRuntimeSession(client, resumeSessionId, cwd) {
 	if (resumeSessionId) {
 		if (client.supportsResumeSession()) {
@@ -1179,9 +1247,26 @@ var AcpRuntimeManager = class {
 			agentArgv: agentArgv ? [...agentArgv] : void 0
 		}) : servers ?? []];
 	}
-	async withRuntimeControlSession(record, sessionMode, run, replacingConfigOption) {
+	resolveSessionPermissions(session) {
+		const { sessionKey, cwd, agentCommand, agentArgv } = session;
+		const { permissionMode = this.options.permissionMode, nonInteractivePermissions = this.options.nonInteractivePermissions, permissionPolicy = this.options.permissionPolicy, onPermissionRequest = this.options.onPermissionRequest } = this.options.sessionPermissions?.({
+			sessionKey,
+			cwd,
+			agentCommand,
+			agentArgv: agentArgv ? [...agentArgv] : void 0
+		}) ?? {};
+		return {
+			permissionMode,
+			nonInteractivePermissions,
+			permissionPolicy,
+			onPermissionRequest
+		};
+	}
+	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 {
@@ -1217,15 +1302,16 @@ var AcpRuntimeManager = class {
 					...record,
 					sessionKey: record.name ?? record.acpxRecordId
 				}),
-				permissionMode: this.options.permissionMode,
-				nonInteractivePermissions: this.options.nonInteractivePermissions,
-				permissionPolicy: this.options.permissionPolicy,
-				onPermissionRequest: this.options.onPermissionRequest,
+				...this.resolveSessionPermissions({
+					...record,
+					sessionKey: record.name ?? record.acpxRecordId
+				}),
 				elicitationModes: this.options.elicitationModes,
 				verbose: this.options.verbose,
 				timeoutMs: this.options.timeoutMs,
 				resumePolicy: resumePolicyForSessionMode(sessionMode),
 				replacingConfigOption,
+				authority,
 				run
 			});
 			return {
@@ -1251,8 +1337,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) => {
@@ -1263,6 +1350,7 @@ var AcpRuntimeManager = class {
 		await previous;
 		try {
 			this.assertOpen();
+			assertControlAuthority(authority);
 			return await run();
 		} finally {
 			release();
@@ -1331,10 +1419,10 @@ var AcpRuntimeManager = class {
 				...agent,
 				sessionKey: input.sessionKey
 			}),
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
+			...this.resolveSessionPermissions({
+				...agent,
+				sessionKey: input.sessionKey
+			}),
 			elicitationModes: this.options.elicitationModes,
 			processLifecycle: this.options.processLifecycle,
 			processLaunchScope: {
@@ -1351,7 +1439,7 @@ var AcpRuntimeManager = class {
 		});
 		let retained = false;
 		try {
-			await client.start();
+			await startRuntimeClient(client, agent, this.options.timeoutMs);
 			this.assertOpen();
 			const session = await createOrLoadRuntimeSession(client, input.resumeSessionId, cwd);
 			const record = await this.prepareInitialRuntimeRecord({
@@ -1455,7 +1543,7 @@ var AcpRuntimeManager = class {
 			return true;
 		};
 		const abortHandler = () => {
-			requestCancel();
+			requestCancel().catch(() => {});
 		};
 		if (input.signal && !input.signal.aborted) input.signal.addEventListener("abort", abortHandler, { once: true });
 		this.queueSessionTask(input.handle.acpxRecordId ?? input.handle.sessionKey, async () => this.runRuntimeTurnTask({
@@ -1505,7 +1593,6 @@ var AcpRuntimeManager = class {
 					stopReason: "cancelled"
 				};
 				else {
-					await this.applyPendingRuntimeTurnCancel(task, turn);
 					const response = await this.runRuntimePrompt(task, turn, sessionId);
 					await this.saveCompletedRuntimeTurn(turn);
 					terminalResult = {
@@ -1516,7 +1603,7 @@ var AcpRuntimeManager = class {
 				}
 			}
 		} catch (error) {
-			terminalResult = this.failRuntimeTurn(task, error);
+			terminalResult = this.handleRuntimeTurnFailure(task, error);
 		}
 		const finalization = await settleAttempt(async () => this.finalizeRuntimeTurn(task, turn));
 		if (!finalization.ok) {
@@ -1536,7 +1623,8 @@ var AcpRuntimeManager = class {
 				promptMessageId: turn.promptMessageId,
 				onPromptRequestWritten: () => task.promptStarted.resolve(),
 				onElicitation: task.input.onElicitation,
-				onPermissionRequest: task.input.onPermissionRequest
+				onPermissionRequest: task.input.onPermissionRequest,
+				authority: task.input
 			});
 		} finally {
 			turn.client.endPromptElicitation?.(sessionId);
@@ -1658,10 +1746,10 @@ var AcpRuntimeManager = class {
 				...record,
 				sessionKey: record.name ?? record.acpxRecordId
 			}),
-			permissionMode: this.options.permissionMode,
-			nonInteractivePermissions: this.options.nonInteractivePermissions,
-			permissionPolicy: this.options.permissionPolicy,
-			onPermissionRequest: this.options.onPermissionRequest,
+			...this.resolveSessionPermissions({
+				...record,
+				sessionKey: record.name ?? record.acpxRecordId
+			}),
 			elicitationModes: this.options.elicitationModes,
 			processLifecycle: this.options.processLifecycle,
 			processLaunchScope: {
@@ -1685,24 +1773,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) {
@@ -1715,14 +1803,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,
@@ -1780,12 +1868,6 @@ var AcpRuntimeManager = class {
 		task.promptStarted.reject(/* @__PURE__ */ new Error("ACP turn cancelled before prompt submission."));
 		return true;
 	}
-	async applyPendingRuntimeTurnCancel(task, turn) {
-		if (!task.state.pendingCancel || !turn.client.hasActivePrompt()) return false;
-		const cancelled = await turn.client.requestCancelActivePrompt();
-		if (cancelled) task.state.pendingCancel = false;
-		return cancelled;
-	}
 	async saveCompletedRuntimeTurn(turn) {
 		turn.record.acpSessionId = turn.activeSessionId;
 		reconcileAgentSessionId(turn.record, turn.record.agentSessionId);
@@ -1796,6 +1878,15 @@ var AcpRuntimeManager = class {
 		applyLifecycleSnapshotToRecord(turn.record, turn.client.getAgentLifecycleSnapshot());
 		await this.options.sessionStore.save(turn.record);
 	}
+	handleRuntimeTurnFailure(task, error) {
+		if (!task.input.signal?.aborted || error !== task.input.signal.reason) return this.failRuntimeTurn(task, error);
+		task.promptStarted.reject(error);
+		task.sessionReady.reject(error);
+		return {
+			status: "cancelled",
+			stopReason: "cancelled"
+		};
+	}
 	failRuntimeTurn(task, error) {
 		task.promptStarted.reject(error);
 		task.sessionReady.reject(error);
@@ -1879,49 +1970,52 @@ var AcpRuntimeManager = class {
 		if (owner) await this.flushSessionOwner(owner);
 		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 setModel(handle, model, 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));
+		await this.withManagerLock(this.runtimeOperationLocks, recordId, async () => this.setModelWithOwnership(handle, model, sessionMode, authority), authority);
 	}
-	async setModelWithOwnership(handle, model, sessionMode) {
+	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);
+			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));
+			const response = await client.setSessionModel(sessionId, model, advertisedModelState(connectedRecord.acpx), authority);
 			connectedRecord.acpx = applyModelSelection(connectedRecord.acpx, model, response);
-		}, { key: "model" });
+		}, { key: "model" }, authority);
 		await this.options.sessionStore.save(result.record);
 	}
-	async setConfigOption(handle, key, value, sessionMode = "persistent") {
+	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;
@@ -1929,13 +2023,13 @@ 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;
 	}
@@ -2125,6 +2219,233 @@ function writeHandleState(handle, state) {
 	handle.agentSessionId = state.agentSessionId;
 }
 //#endregion
+//#region src/runtime/shared.ts
+const SHARED_BACKEND = "acpx-shared";
+function invalidOption(message) {
+	throw new AcpRuntimeError("ACP_INVALID_RUNTIME_OPTION", message);
+}
+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 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
+		}
+	};
+}
+/** 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",
+			"sessionPermissions",
+			"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();
+	}
+	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 {
+			...normalizeAgentCommandInput(this.registry.resolve(input.agent)),
+			cwd: path.resolve(input.cwd ?? this.options.cwd),
+			name: input.sessionKey.trim() || void 0
+		};
+	}
+	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.assertActive || 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 {
+			requestId: input.requestId,
+			promptStarted: promptStarted.promise,
+			events: events.iterate(),
+			result,
+			cancel,
+			closeStream: async () => {
+				events.clear();
+				events.close();
+			}
+		};
+	}
+	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: [
@@ -2232,6 +2553,7 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
+			assertActive: input.assertActive,
 			onElicitation: input.onElicitation,
 			onPermissionRequest: input.onPermissionRequest
 		}));
@@ -2265,6 +2587,7 @@ var AcpxRuntime = class {
 			requestId: input.requestId,
 			timeoutMs: input.timeoutMs,
 			signal: input.signal,
+			assertActive: input.assertActive,
 			onElicitation: input.onElicitation,
 			onPermissionRequest: input.onPermissionRequest
 		});
@@ -2286,15 +2609,15 @@ 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);
+		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);
@@ -2377,6 +2700,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, inspectAgentModels, isAcpRuntimeError, isRequestedModelUnsupportedError };
 
 //# sourceMappingURL=runtime.js.map