acpx 0.18.0 → 0.19.1

package/dist/{queue-owner-runtime-Cr0dWJuL.js → queue-owner-runtime-C4OOosbo.js}

@@ -1,5 +1,5 @@
-import { $ as setPerfGauge, A as isoNow$1, At as AcpxOperationalError, Bt as QueueConnectionError, C as promptToDisplayText, D as findGitRepositoryRoot, E as absolutePath, Ft as ClaudeAcpSessionCreateTimeoutError, Gt as SessionResumeRequiredError, H as normalizeAgentSessionId, Ht as SessionModeReplayError, I as resolveSessionRecord, It as CopilotAcpUnsupportedError, J as getPerfMetricsSnapshot, Kt as UnsupportedPromptContentError, L as writeSessionRecord, Lt as GeminiAcpStartupTimeoutError, Mt as AgentSpawnError, N as normalizeName, Nt as AgentStartupError, Pt as AuthPolicyError, Q as resetPerfMetrics, Rt as PermissionDeniedError, St as EXIT_CODES, Tt as OUTPUT_ERROR_ORIGINS, U as SESSION_JOURNAL_SCHEMA, Ut as SessionModelReplayError, V as extractAgentSessionId, Vt as SessionConfigOptionReplayError, W as SessionJournalReader, X as measurePerf, Y as incrementPerfCounter, Z as recordPerfDuration, _ as waitMs$1, _t as isProcessDefinitelyDead, a as trySetModelOnRunningOwner, b as getUnsupportedPromptContentMessage, bt as isAcpResourceNotFoundError, c as queueRequestExceedsLimit, dt as sessionEventActivePath, et as startPerfTimer, f as refreshQueueOwnerLease, ft as sessionEventLockPath, g as tryAcquireQueueOwnerLease, gt as isProcessAlive, h as terminateQueueOwnerForSession, i as trySetModeOnRunningOwner, it as isSessionUpdateNotification, jt as AgentDisconnectedError, k as findSessionByDirectoryWalk, l as parseQueueRequest, lt as defaultSessionEventLog, m as terminateProcess, n as tryCloseSessionOnRunningOwner, nt as isAcpJsonRpcMessage, o as trySubmitToRunningOwner, p as releaseQueueOwnerLease, pt as sessionEventSegmentPath, q as formatPerfMetric, r as trySetConfigOptionOnRunningOwner, rt as isAcpMessageObject, s as queueRequestByteLimit, t as tryCancelOnRunningOwner, ut as sessionBaseDir, v as QueueLeaseGuardSettlementError, vt as extractAcpError, w as textPrompt, wt as OUTPUT_ERROR_CODES, yt as formatUnknownErrorMessage, zt as PermissionPromptUnavailableError } from "./ipc-BJrvfNXr.js";
-import { A as resolveAgentCommandParts, C as asAbsoluteCwd, E as isoNow$2, F as waitForSpawn, M as runTimedExecFile, N as splitCommandLine, P as waitForChildExit, S as PROCESS_HELPER_TIMEOUT_MS, T as isChildProcessRunning, _ as buildSpawnCommandOptions, b as readWindowsEnvValue, f as resolveBuiltInAgentLaunch, g as buildAgentSpawnCommand, j as resolveAgentSessionCwd, k as requireAgentStdio, v as buildTerminalShellSpawnCommand, w as basenameToken, x as resolveWindowsExecutablePath, y as buildTerminalSpawnCommand } from "./agent-registry-DdKB-zia.js";
+import { $ as measurePerf, A as findGitRepositoryRoot, B as writeSessionRecord, Bt as PermissionDeniedError, C as getUnsupportedPromptContentMessage, D as textPrompt, Dt as OUTPUT_ERROR_ORIGINS, E as promptToDisplayText, Et as OUTPUT_ERROR_CODES, Ft as AgentStartupError, G as normalizeAgentSessionId, Gt as SessionModelReplayError, Ht as QueueConnectionError, I as normalizeName, It as AuthPolicyError, Jt as UnsupportedPromptContentError, K as SESSION_JOURNAL_SCHEMA, Lt as ClaudeAcpSessionCreateTimeoutError, M as findSessionByDirectoryWalk, Mt as AcpxOperationalError, N as isoNow$1, Nt as AgentDisconnectedError, Pt as AgentSpawnError, Q as incrementPerfCounter, Rt as CopilotAcpUnsupportedError, St as isAcpResourceNotFoundError, Ut as SessionConfigOptionReplayError, Vt as PermissionPromptUnavailableError, W as extractAgentSessionId, Wt as SessionModeReplayError, X as formatPerfMetric, Z as getPerfMetricsSnapshot, _ as waitMs$1, a as trySetModelOnRunningOwner, at as isAcpJsonRpcMessage, b as lockOwnerPid, bt as extractAcpError, c as queueRequestExceedsLimit, et as recordPerfDuration, f as refreshQueueOwnerLease, ft as defaultSessionEventLog, g as tryAcquireQueueOwnerLease, gt as sessionEventSegmentPath, h as terminateQueueOwnerForSession, ht as sessionEventLockPath, i as trySetModeOnRunningOwner, k as absolutePath, l as parseQueueRequest, m as terminateProcess, mt as sessionEventActivePath, n as tryCloseSessionOnRunningOwner, nt as setPerfGauge, o as trySubmitToRunningOwner, ot as isAcpMessageObject, p as releaseQueueOwnerLease, pt as sessionBaseDir, q as SessionJournalReader, qt as SessionResumeRequiredError, r as trySetConfigOptionOnRunningOwner, rt as startPerfTimer, s as queueRequestByteLimit, st as isSessionUpdateNotification, t as tryCancelOnRunningOwner, tt as resetPerfMetrics, v as QueueLeaseGuardSettlementError, wt as EXIT_CODES, x as ProcessDescendants, xt as formatUnknownErrorMessage, y as createLockOwner, yt as isProcessAlive, z as resolveSessionRecord, zt as GeminiAcpStartupTimeoutError } from "./ipc-DAApJ5mi.js";
+import { A as requireAgentStdio, C as PROCESS_HELPER_TIMEOUT_MS, D as isoNow$2, E as isChildProcessRunning, F as waitForChildExit, I as waitForSpawn, M as resolveAgentSessionCwd, N as runTimedExecFile, P as splitCommandLine, T as basenameToken, _ as buildSpawnCommandOptions, b as readWindowsEnvValue, f as resolveBuiltInAgentLaunch, g as buildAgentSpawnCommand, j as resolveAgentCommandParts, v as buildTerminalShellSpawnCommand, w as asAbsoluteCwd, x as resolveWindowsExecutablePath, y as buildTerminalSpawnCommand } from "./agent-registry-DWlx5BQ4.js";
 import fs, { readFileSync, realpathSync } from "node:fs";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import path from "node:path";
@@ -485,6 +485,17 @@ function normalizeQueueOwnerTtlMs(ttlMs) {
 	return Math.round(ttlMs);
 }
 //#endregion
+//#region src/file-read-window.ts
+function sliceReadWindow(content, line, limit) {
+	if (line == null && limit == null) return content;
+	const lines = content.split("\n");
+	const startIndex = Math.max(0, (line == null ? 1 : Math.max(1, Math.trunc(line))) - 1);
+	const maxLines = limit == null ? void 0 : Math.max(0, Math.trunc(limit));
+	if (maxLines === 0) return "";
+	const endIndex = maxLines == null ? lines.length : Math.min(lines.length, startIndex + maxLines);
+	return lines.slice(startIndex, endIndex).join("\n");
+}
+//#endregion
 //#region src/permission-prompt.ts
 let promptQueue = Promise.resolve();
 async function promptForPermission(options) {
@@ -598,7 +609,7 @@ var FileSystemHandlers = class {
 			if (this.permissionMode === "deny-all") throw new PermissionDeniedError("Permission denied for fs/read_text_file (--deny-all)");
 			const content = await (await this.getWorkspace()).readText(filePath);
 			assertControlAuthority(authority);
-			const sliced = this.sliceContent(content, params.line, params.limit);
+			const sliced = sliceReadWindow(content, params.line, params.limit);
 			this.emitOperation({
 				method: "fs/read_text_file",
 				status: "completed",
@@ -686,15 +697,6 @@ var FileSystemHandlers = class {
 			maxBytes: Infinity
 		});
 	}
-	sliceContent(content, line, limit) {
-		if (line == null && limit == null) return content;
-		const lines = content.split("\n");
-		const startIndex = Math.max(0, (line == null ? 1 : Math.max(1, Math.trunc(line))) - 1);
-		const maxLines = limit == null ? void 0 : Math.max(0, Math.trunc(limit));
-		if (maxLines === 0) return "";
-		const endIndex = maxLines == null ? lines.length : Math.min(lines.length, startIndex + maxLines);
-		return lines.slice(startIndex, endIndex).join("\n");
-	}
 	readWindowDetails(line, limit) {
 		if (line == null && limit == null) return;
 		return `line=${line == null ? 1 : Math.max(1, Math.trunc(line))}, limit=${limit == null ? "all" : Math.max(0, Math.trunc(limit))}`;
@@ -1078,63 +1080,22 @@ function compareVersionParts(left, right) {
 	}
 	return 0;
 }
-async function detectGeminiVersion(command) {
-	const versionLine = (await readCommandOutput(command, ["--version"], GEMINI_VERSION_TIMEOUT_MS))?.split(/\r?\n/).map((line) => line.trim()).find((line) => /\d+\.\d+\.\d+/.test(line));
+async function detectGeminiVersion(command, context, diagnostic = false) {
+	const versionLine = (await context.readOutput(command, ["--version"], GEMINI_VERSION_TIMEOUT_MS, diagnostic))?.split(/\r?\n/).map((line) => line.trim()).find((line) => /\d+\.\d+\.\d+/.test(line));
 	return parseGeminiVersion(versionLine);
 }
-async function resolveGeminiCommandArgs(command, args) {
+async function resolveGeminiCommandArgs(command, args, context) {
 	if (basenameToken(command) !== "gemini" || !args.includes("--acp")) return [...args];
-	const version = await detectGeminiVersion(command);
+	const version = await detectGeminiVersion(command, context);
 	if (version && compareVersionParts(version.parts, GEMINI_ACP_FLAG_VERSION) < 0) return args.map((arg) => arg === "--acp" ? "--experimental-acp" : arg);
 	return [...args];
 }
-async function readCommandOutput(command, args, timeoutMs) {
-	return await new Promise((resolve) => {
-		const child = spawn(command, [...args], buildSpawnCommandOptions(command, {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			windowsHide: true
-		}));
-		let stdout = "";
-		let stderr = "";
-		let settled = false;
-		const finish = (value) => {
-			if (settled) return;
-			settled = true;
-			clearTimeout(timer);
-			child.removeAllListeners();
-			child.stdout?.removeAllListeners();
-			child.stderr?.removeAllListeners();
-			resolve(value);
-		};
-		const timer = setTimeout(() => {
-			child.kill("SIGKILL");
-			finish(void 0);
-		}, timeoutMs);
-		child.stdout?.setEncoding("utf8");
-		child.stderr?.setEncoding("utf8");
-		child.stdout?.on("data", (chunk) => {
-			stdout += chunk;
-		});
-		child.stderr?.on("data", (chunk) => {
-			stderr += chunk;
-		});
-		child.once("error", () => {
-			finish(void 0);
-		});
-		child.once("close", () => {
-			finish(`${stdout}\n${stderr}`);
-		});
-	});
-}
-async function buildGeminiAcpStartupTimeoutMessage(command) {
+async function buildGeminiAcpStartupTimeoutMessage(command, context) {
 	const parts = ["Gemini CLI ACP startup timed out before initialize completed.", "This usually means the local Gemini CLI is waiting on interactive OAuth or has incompatible ACP subprocess behavior."];
-	const version = await detectGeminiVersion(command);
+	const version = await detectGeminiVersion(command, context, true);
 	if (version) parts.push(`Detected Gemini CLI version: ${version.raw}.`);
-	if (!process.env.GEMINI_API_KEY && !process.env.GOOGLE_API_KEY) parts.push("No GEMINI_API_KEY or GOOGLE_API_KEY was set for non-interactive auth.");
+	const env = context.env;
+	if (!env.GEMINI_API_KEY && !env.GOOGLE_API_KEY) parts.push("No GEMINI_API_KEY or GOOGLE_API_KEY was set for non-interactive auth.");
 	parts.push("Try upgrading Gemini CLI and using API-key-based auth for non-interactive ACP runs.");
 	return parts.join(" ");
 }
@@ -1145,16 +1106,17 @@ function buildClaudeAcpSessionCreateTimeoutMessage() {
 		"In harnessed or non-interactive runs, prefer --approve-all with nonInteractivePermissions=deny, upgrade Claude Code and the Claude ACP adapter, or use acpx claude exec as a one-shot fallback."
 	].join(" ");
 }
-async function buildCopilotAcpUnsupportedMessage(command) {
-	const parts = ["GitHub Copilot CLI ACP stdio mode is not available in the installed copilot binary.", "acpx copilot expects a Copilot CLI release that supports --acp --stdio."];
-	const helpOutput = await readCommandOutput(command, ["--help"], COPILOT_HELP_TIMEOUT_MS);
-	if (typeof helpOutput === "string" && !helpOutput.includes("--acp")) parts.push("Detected copilot --help output without --acp support.");
-	parts.push("Upgrade GitHub Copilot CLI to a release with ACP stdio support, or use --agent with another ACP-compatible adapter in the meantime.");
-	return parts.join(" ");
+function buildCopilotAcpUnsupportedMessage() {
+	return [
+		"GitHub Copilot CLI ACP stdio mode is not available in the installed copilot binary.",
+		"acpx copilot expects a Copilot CLI release that supports --acp --stdio.",
+		"Detected copilot --help output without --acp support.",
+		"Upgrade GitHub Copilot CLI to a release with ACP stdio support, or use --agent with another ACP-compatible adapter in the meantime."
+	].join(" ");
 }
-async function ensureCopilotAcpSupport(command) {
-	const helpOutput = await readCommandOutput(command, ["--help"], COPILOT_HELP_TIMEOUT_MS);
-	if (typeof helpOutput === "string" && !helpOutput.includes("--acp")) throw new CopilotAcpUnsupportedError(await buildCopilotAcpUnsupportedMessage(command), { retryable: false });
+async function ensureCopilotAcpSupport(command, context) {
+	const helpOutput = await context.readOutput(command, ["--help"], COPILOT_HELP_TIMEOUT_MS);
+	if (typeof helpOutput === "string" && !helpOutput.includes("--acp")) throw new CopilotAcpUnsupportedError(buildCopilotAcpUnsupportedMessage(), { retryable: false });
 }
 function buildClaudeCodeOptionsMeta(options, isolateUserSettings = false) {
 	const claudeCodeOptions = {};
@@ -1375,6 +1337,73 @@ function resolveClientCapabilities(params) {
 	};
 }
 //#endregion
+//#region src/acp/command-probe.ts
+var CommandProbeAdmissionError = class extends Error {
+	reason;
+	constructor(reason) {
+		super("Agent command admission rejected", { cause: reason });
+		this.reason = reason;
+		this.name = "CommandProbeAdmissionError";
+	}
+};
+async function admitCommandProbe(admit) {
+	try {
+		return await admit();
+	} catch (error) {
+		throw new CommandProbeAdmissionError(error);
+	}
+}
+/** Collect only this short adapter command; its client owns process retirement. */
+function captureCommandProbeOutput(child, timeoutMs, retire) {
+	let stdout = "";
+	let stderr = "";
+	let settled = false;
+	let disposed = false;
+	let timer;
+	let resolveResult;
+	const result = new Promise((resolve) => {
+		resolveResult = resolve;
+	});
+	const finish = (value) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		resolveResult(value);
+	};
+	const fail = () => {
+		if (disposed) return;
+		finish(void 0);
+		retire().catch(() => {});
+	};
+	const onStdout = (chunk) => {
+		if (!settled) stdout += chunk;
+	};
+	const onStderr = (chunk) => {
+		if (!settled) stderr += chunk;
+	};
+	const onClose = () => finish(`${stdout}\n${stderr}`);
+	child.stdout?.setEncoding("utf8");
+	child.stderr?.setEncoding("utf8");
+	child.stdout?.on("data", onStdout);
+	child.stderr?.on("data", onStderr);
+	child.on("error", fail);
+	child.stdout?.on("error", fail);
+	child.stderr?.on("error", fail);
+	child.once("close", onClose);
+	timer = setTimeout(fail, timeoutMs);
+	return {
+		result,
+		dispose: () => {
+			disposed = true;
+			finish(void 0);
+			clearTimeout(timer);
+			child.stdout?.off("data", onStdout);
+			child.stderr?.off("data", onStderr);
+			child.off("close", onClose);
+		}
+	};
+}
+//#endregion
 //#region src/acp/model-support.ts
 const REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE = "ACP_MODEL_UNSUPPORTED";
 const REQUESTED_MODEL_UNSUPPORTED_REASONS = ["missing-capability", "unadvertised-model"];
@@ -1556,15 +1585,22 @@ function enqueueNdJsonLine(agentCommand, line, controller) {
 		console.error("Failed to parse JSON message:", trimmedLine, err);
 	}
 }
-function enqueueNdJsonLines(agentCommand, lines, controller) {
+function enqueueNdJsonChunk(agentCommand, chunk, fragments, controller) {
+	const lines = chunk.split("\n");
+	const suffix = lines.pop() || "";
+	if (lines.length > 0 && fragments.length > 0) {
+		lines[0] = fragments.join("") + lines[0];
+		fragments.length = 0;
+	}
 	for (const line of lines) enqueueNdJsonLine(agentCommand, line, controller);
+	if (suffix) fragments.push(suffix);
 }
 function createNdJsonMessageStream(agentCommand, output, input, maxMessageBytes, onReadError) {
 	const textEncoder = new TextEncoder();
 	const textDecoder = new TextDecoder();
 	return {
 		readable: new ReadableStream({ async start(controller) {
-			let content = "";
+			const fragments = [];
 			let retainedBytes = 0;
 			const reader = input.getReader();
 			try {
@@ -1572,10 +1608,7 @@ function createNdJsonMessageStream(agentCommand, output, input, maxMessageBytes,
 					const { value, done } = await reader.read();
 					if (done) break;
 					if (maxMessageBytes !== void 0) retainedBytes = countLineBytes(value, retainedBytes, maxMessageBytes);
-					content += textDecoder.decode(value, { stream: true });
-					const lines = content.split("\n");
-					content = lines.pop() || "";
-					enqueueNdJsonLines(agentCommand, lines, controller);
+					enqueueNdJsonChunk(agentCommand, textDecoder.decode(value, { stream: true }), fragments, controller);
 				}
 				controller.close();
 			} catch (err) {
@@ -1666,89 +1699,6 @@ function promptRequestOwner(message) {
 	} : void 0;
 }
 //#endregion
-//#region src/acp/process-descendants.ts
-function parseProcessTable(output) {
-	const table = /* @__PURE__ */ new Map();
-	for (const line of output.split("\n")) {
-		const match = /^\s*(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
-		if (match && !match[3].startsWith("Z")) {
-			const pid = Number(match[1]);
-			if (Number.isSafeInteger(pid) && pid > 1 && pid !== process.pid) table.set(pid, {
-				pid,
-				parentPid: Number(match[2]),
-				birth: match[4]
-			});
-		}
-	}
-	return table;
-}
-function includeDescendants(table, owned) {
-	let expanded;
-	do {
-		expanded = false;
-		for (const identity of table.values()) if (owned.has(identity.parentPid) && !owned.has(identity.pid)) {
-			owned.add(identity.pid);
-			expanded = true;
-		}
-	} while (expanded);
-}
-/** Best-effort POSIX cleanup for descendants witnessed during this child launch. */
-var ProcessDescendants = class {
-	child;
-	identities = /* @__PURE__ */ new Map();
-	pending;
-	retired = false;
-	constructor(child) {
-		this.child = child;
-	}
-	capture(timeoutMs = PROCESS_HELPER_TIMEOUT_MS) {
-		if (this.retired || process.platform === "win32") return Promise.resolve(true);
-		this.pending ??= this.readSnapshot(timeoutMs).finally(() => {
-			this.pending = void 0;
-		});
-		return this.pending;
-	}
-	async readSnapshot(timeoutMs) {
-		try {
-			const output = await runTimedExecFile("ps", ["-eo", "pid=,ppid=,stat=,lstart="], { timeoutMs });
-			if (!this.retired) this.refresh(parseProcessTable(output));
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	refresh(table) {
-		const owned = /* @__PURE__ */ new Set();
-		for (const [pid, identity] of this.identities) if (table.get(pid)?.birth === identity.birth) owned.add(pid);
-		const root = this.child.pid;
-		if (root && isChildProcessRunning(this.child)) owned.add(root);
-		includeDescendants(table, owned);
-		owned.delete(root ?? 0);
-		this.identities = new Map([...table].filter(([pid]) => owned.has(pid)));
-	}
-	async signal(signal, timeoutMs) {
-		if (!await this.capture(timeoutMs) || this.retired) return;
-		for (const pid of this.identities.keys()) try {
-			process.kill(pid, signal);
-		} catch {
-			this.identities.delete(pid);
-		}
-	}
-	async waitForExit(timeoutMs) {
-		const deadline = Date.now() + timeoutMs;
-		do {
-			if (!await this.capture(Math.max(1, deadline - Date.now()))) return false;
-			if (this.identities.size === 0) return true;
-			await setTimeout$1(Math.min(100, Math.max(0, deadline - Date.now())));
-		} while (Date.now() < deadline);
-		return false;
-	}
-	retire() {
-		this.retired = true;
-		this.identities.clear();
-	}
-};
-//#endregion
 //#region src/acp/session-control-errors.ts
 const SESSION_CONTROL_UNSUPPORTED_ACP_CODES = /* @__PURE__ */ new Set([-32601, -32602]);
 function asRecord$1(value) {
@@ -1812,12 +1762,20 @@ function readTerminalOutputCeiling() {
 	if (!/^\d+$/.test(raw) || !Number.isSafeInteger(bytes)) throw new Error("ACPX_TERMINAL_MAX_OUTPUT_BYTES must be a non-negative safe integer; zero disables the host ceiling");
 	return bytes === 0 ? void 0 : bytes;
 }
+function resolveTerminalOutputLimit(requested, ceiling) {
+	return Math.min(Math.max(0, Math.round(requested ?? DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES)), ceiling ?? Number.POSITIVE_INFINITY);
+}
+function tracksTerminalDescendants(terminal) {
+	return terminal.killProcessGroup || terminal.descendants !== void 0;
+}
+function createTerminalDescendants(proc, killProcessGroup) {
+	return process.platform === "win32" && killProcessGroup ? void 0 : new ProcessDescendants(proc, { ownProcessGroup: true });
+}
 function trimToUtf8Boundary(buffer, limit) {
 	if (limit <= 0) return Buffer.alloc(0);
-	if (buffer.length <= limit) return buffer;
-	let start = buffer.length - limit;
+	let start = Math.max(0, buffer.length - limit);
 	while (start < buffer.length && (buffer[start] & 192) === 128) start += 1;
-	if (start >= buffer.length) start = buffer.length - limit;
+	if (start >= buffer.length) return Buffer.alloc(0);
 	return buffer.subarray(start);
 }
 async function defaultConfirmExecute(commandLine, signal) {
@@ -1854,7 +1812,8 @@ var TerminalManager = class {
 		this.onOperation = options.onOperation;
 		this.usesDefaultConfirmExecute = options.confirmExecute == null;
 		this.confirmExecute = options.confirmExecute ?? defaultConfirmExecute;
-		this.killGraceMs = Math.max(0, Math.round(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS));
+		const killGraceMs = Math.max(0, Math.round(options.killGraceMs ?? DEFAULT_KILL_GRACE_MS));
+		this.killGraceMs = Number.isFinite(killGraceMs) && killGraceMs <= 2147483647 ? killGraceMs : 1;
 		this.processHelperTimeoutMs = Math.max(1, Math.round(options.processHelperTimeoutMs ?? 8e3));
 	}
 	updatePermissionPolicy(permissionMode, nonInteractivePermissions) {
@@ -1875,8 +1834,7 @@ var TerminalManager = class {
 			const approved = await this.isExecuteApproved(commandLine, authority?.signal);
 			assertControlAuthority(authority);
 			if (!approved) throw new PermissionDeniedError("Permission denied for terminal/create");
-			const requestedLimit = Math.max(0, Math.round(params.outputByteLimit ?? DEFAULT_TERMINAL_OUTPUT_LIMIT_BYTES));
-			const outputByteLimit = Math.min(requestedLimit, this.outputCeilingBytes ?? Number.POSITIVE_INFINITY);
+			const outputByteLimit = resolveTerminalOutputLimit(params.outputByteLimit, this.outputCeilingBytes);
 			const { proc, spawnCommand } = await spawnTerminalProcess(params, this.cwd, authority);
 			let resolveExit = () => {};
 			const exitPromise = new Promise((resolve) => {
@@ -1886,6 +1844,7 @@ var TerminalManager = class {
 				process: proc,
 				killProcessGroup: spawnCommand.killProcessGroup,
 				descendantPids: /* @__PURE__ */ new Set(),
+				descendants: createTerminalDescendants(proc, spawnCommand.killProcessGroup),
 				processHelperTimeoutMs: this.processHelperTimeoutMs,
 				output: Buffer.alloc(0),
 				truncated: false,
@@ -1899,10 +1858,8 @@ var TerminalManager = class {
 				const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
 				if (bytes.length === 0) return;
 				terminal.output = Buffer.concat([terminal.output, bytes]);
-				if (terminal.output.length > terminal.outputByteLimit) {
-					terminal.output = trimToUtf8Boundary(terminal.output, terminal.outputByteLimit);
-					terminal.truncated = true;
-				}
+				terminal.truncated ||= terminal.output.length > terminal.outputByteLimit;
+				if (terminal.truncated) terminal.output = trimToUtf8Boundary(terminal.output, terminal.outputByteLimit);
 			};
 			proc.stdout.on("data", appendOutput);
 			proc.stderr.on("data", appendOutput);
@@ -1911,9 +1868,10 @@ var TerminalManager = class {
 			proc.once("exit", (exitCode, signal) => {
 				terminal.exitCode = exitCode;
 				terminal.signal = signal;
-				terminal.processGroupSnapshotPromise = rememberProcessGroupPids(terminal);
+				terminal.processGroupSnapshotPromise = terminal.descendants ? terminal.descendants.capture(terminal.processHelperTimeoutMs).then(() => {}) : rememberProcessGroupPids(terminal);
 				(async () => {
 					await terminal.processGroupSnapshotPromise;
+					terminal.processGroupSnapshotPromise = void 0;
 					terminal.resolveExit({
 						exitCode: exitCode ?? null,
 						signal: signal ?? null
@@ -1923,6 +1881,7 @@ var TerminalManager = class {
 			const terminalId = randomUUID();
 			this.terminals.set(terminalId, terminal);
 			try {
+				await terminal.descendants?.capture(terminal.processHelperTimeoutMs);
 				assertControlAuthority(authority);
 			} catch (error) {
 				await this.releaseTerminal({
@@ -2036,6 +1995,9 @@ var TerminalManager = class {
 		try {
 			await this.killProcess(terminal);
 			await terminal.exitPromise.catch(() => {});
+			terminal.descendants?.retire();
+			terminal.process.stdout.destroy();
+			terminal.process.stderr.destroy();
 			terminal.output = Buffer.alloc(0);
 			this.terminals.delete(params.terminalId);
 			this.emitOperation({
@@ -2058,10 +2020,13 @@ var TerminalManager = class {
 		}
 	}
 	async shutdown() {
-		for (const terminalId of Array.from(this.terminals.keys())) await this.releaseTerminal({
+		const results = await Promise.allSettled(Array.from(this.terminals.keys(), (terminalId) => this.releaseTerminal({
 			terminalId,
 			sessionId: "shutdown"
-		});
+		})));
+		const failures = [];
+		for (const result of results) if (result.status === "rejected") failures.push(result.reason);
+		if (failures.length > 0) throw new AggregateError(failures, "Terminal shutdown failed", { cause: failures[0] });
 	}
 	getTerminal(terminalId) {
 		return this.terminals.get(terminalId);
@@ -2079,13 +2044,13 @@ var TerminalManager = class {
 		return terminal.exitCode === void 0 && terminal.signal === void 0;
 	}
 	async killProcess(terminal) {
-		if (!this.isRunning(terminal) && !terminal.killProcessGroup) return;
+		if (!this.isRunning(terminal) && !tracksTerminalDescendants(terminal)) return;
 		try {
 			await this.signalProcess(terminal, "SIGTERM");
 		} catch {
 			return;
 		}
-		if (await this.waitForCleanupAfterSignal(terminal) && !terminal.killProcessGroup) return;
+		if (await this.waitForCleanupAfterSignal(terminal) && (!terminal.killProcessGroup || terminal.descendants)) return;
 		try {
 			await this.signalProcess(terminal, "SIGKILL");
 		} catch {
@@ -2094,15 +2059,16 @@ var TerminalManager = class {
 		await this.waitForFinalCleanup(terminal);
 	}
 	async signalProcess(terminal, signal) {
+		if (terminal.descendants) {
+			await terminal.descendants.signal(signal, terminal.processHelperTimeoutMs);
+			if (this.isRunning(terminal)) terminal.process.kill(signal);
+			return;
+		}
 		const pid = terminal.process.pid;
 		if (terminal.killProcessGroup && pid && process.platform === "win32") {
 			await this.signalWindowsProcessGroup(terminal, pid, signal);
 			return;
 		}
-		if (terminal.killProcessGroup && pid) {
-			await this.signalPosixProcessGroup(terminal, pid, signal);
-			return;
-		}
 		terminal.process.kill(signal);
 	}
 	async signalWindowsProcessGroup(terminal, pid, signal) {
@@ -2113,14 +2079,6 @@ var TerminalManager = class {
 		}
 		for (const descendantPid of terminal.descendantPids) await killWindowsProcessTree(descendantPid, signal, terminal.processHelperTimeoutMs);
 	}
-	async signalPosixProcessGroup(terminal, pid, signal) {
-		await this.captureDescendantPids(terminal, pid);
-		if (hasLiveProcessGroup(pid)) {
-			sendSignal(-pid, signal);
-			return;
-		}
-		for (const descendantPid of terminal.descendantPids) sendSignal(descendantPid, signal);
-	}
 	async captureDescendantPids(terminal, pid) {
 		if (!this.isRunning(terminal)) await terminal.processGroupSnapshotPromise?.catch(() => {});
 		for (const descendantPid of await listDescendantPids(pid, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(descendantPid);
@@ -2129,12 +2087,13 @@ var TerminalManager = class {
 		if (!await this.waitForCleanupAfterSignal(terminal) && process.platform === "win32") throw new Error("Terminal process cleanup did not finish after SIGKILL");
 	}
 	async waitForCleanupAfterSignal(terminal) {
-		return await Promise.race([this.waitForTerminalAndTrackedDescendants(terminal).then(() => true), waitMs(this.killGraceMs).then(() => false)]);
-	}
-	async waitForTerminalAndTrackedDescendants(terminal) {
-		await terminal.exitPromise;
-		while (hasLiveTerminalProcessGroup(terminal)) await waitMs(25);
-		while (hasLivePid(terminal.descendantPids)) await waitMs(25);
+		const deadline = performance.now() + this.killGraceMs;
+		while (this.isRunning(terminal) || terminal.processGroupSnapshotPromise || await hasLiveTerminalDescendants(terminal, deadline - performance.now()) || hasLivePid(terminal.descendantPids)) {
+			const remaining = deadline - performance.now();
+			if (remaining <= 0) return false;
+			await waitMs(Math.min(25, remaining));
+		}
+		return true;
 	}
 };
 async function spawnTerminalProcess(params, defaultCwd, authority) {
@@ -2155,7 +2114,7 @@ async function spawnTerminalProcess(params, defaultCwd, authority) {
 }
 async function spawnAndWait(spawnCommand, params, defaultCwd, authority) {
 	const spawnOptions = buildTerminalSpawnOptions(spawnCommand.command, params.cwd ?? defaultCwd, params.env);
-	if (spawnCommand.killProcessGroup) spawnOptions.detached = true;
+	if (spawnCommand.killProcessGroup || process.platform !== "win32") spawnOptions.detached = true;
 	assertControlAuthority(authority);
 	const proc = spawn(spawnCommand.command, spawnCommand.args, spawnOptions);
 	await waitForSpawn(proc);
@@ -2183,7 +2142,7 @@ function commandPathExists(command, cwd) {
 async function listDescendantPids(rootPid, timeoutMs) {
 	let output;
 	try {
-		output = await runProcessListCommand(timeoutMs);
+		output = await runWindowsProcessListCommand(timeoutMs);
 	} catch {
 		return [];
 	}
@@ -2216,38 +2175,10 @@ function parseProcessListLine(line) {
 		parentPid
 	};
 }
-async function runProcessListCommand(timeoutMs) {
-	if (process.platform === "win32") return await runWindowsProcessListCommand(timeoutMs);
-	return await runTimedExecFile("ps", ["-eo", "pid=,ppid="], { timeoutMs });
-}
 async function rememberProcessGroupPids(terminal) {
 	const processGroupId = terminal.process.pid;
 	if (!terminal.killProcessGroup || !processGroupId) return;
-	if (process.platform === "win32") {
-		for (const pid of await listDescendantPids(processGroupId, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(pid);
-		return;
-	}
-	for (const pid of await listProcessGroupPids(processGroupId, terminal.processHelperTimeoutMs)) if (pid !== processGroupId) terminal.descendantPids.add(pid);
-}
-async function listProcessGroupPids(processGroupId, timeoutMs) {
-	let output;
-	try {
-		output = await runProcessGroupListCommand(timeoutMs);
-	} catch {
-		return [];
-	}
-	const pids = [];
-	for (const line of output.split("\n")) {
-		const match = line.trim().match(/^(\d+)\s+(\d+)$/);
-		if (!match) continue;
-		const pid = Number(match[1]);
-		const pgid = Number(match[2]);
-		if (Number.isInteger(pid) && Number.isInteger(pgid) && pid > 0 && pgid === processGroupId) pids.push(pid);
-	}
-	return pids;
-}
-async function runProcessGroupListCommand(timeoutMs) {
-	return await runTimedExecFile("ps", ["-eo", "pid=,pgid="], { timeoutMs });
+	for (const pid of await listDescendantPids(processGroupId, terminal.processHelperTimeoutMs)) terminal.descendantPids.add(pid);
 }
 async function runWindowsProcessListCommand(timeoutMs) {
 	const command = ["Get-CimInstance Win32_Process |", "ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"].join(" ");
@@ -2275,22 +2206,11 @@ async function killWindowsProcessTree(pid, signal, timeoutMs = PROCESS_HELPER_TI
 		});
 	} catch {}
 }
-function sendSignal(pid, signal) {
-	try {
-		process.kill(pid, signal);
-	} catch {}
-}
-function hasLiveProcessGroup(processGroupId) {
-	try {
-		process.kill(-processGroupId, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function hasLiveTerminalProcessGroup(terminal) {
-	const pid = terminal.process.pid;
-	return Boolean(terminal.killProcessGroup && pid && process.platform !== "win32" && hasLiveProcessGroup(pid));
+async function hasLiveTerminalDescendants(terminal, timeoutMs) {
+	const descendants = terminal.descendants;
+	if (!descendants) return false;
+	if (timeoutMs > 0) await descendants.capture(Math.min(terminal.processHelperTimeoutMs, timeoutMs));
+	return descendants.hasTrackedProcesses();
 }
 function hasLivePid(pids) {
 	for (const pid of pids) try {
@@ -2400,26 +2320,13 @@ function childProcessIsRunning(agent) {
 function cancelledPermissionResponse() {
 	return { outcome: { outcome: "cancelled" } };
 }
-function shouldSuppressSdkConsoleError(args) {
-	if (args.length === 0) return false;
-	return typeof args[0] === "string" && args[0] === "Error handling request";
-}
-function installSdkConsoleErrorSuppression() {
-	const originalConsoleError = console.error;
-	console.error = (...args) => {
-		if (shouldSuppressSdkConsoleError(args)) return;
-		originalConsoleError(...args);
-	};
-	return () => {
-		console.error = originalConsoleError;
-	};
-}
 var AcpClient = class {
 	options;
 	connection;
 	agent;
 	agentDescendants = /* @__PURE__ */ new WeakMap();
 	agentCleanups = /* @__PURE__ */ new WeakMap();
+	commandProbes = /* @__PURE__ */ new Set();
 	initResult;
 	loadedSessionId;
 	eventHandlers;
@@ -2441,6 +2348,7 @@ var AcpClient = class {
 	cancellingSessionIds = /* @__PURE__ */ new Set();
 	permissionAbortControllers = /* @__PURE__ */ new Map();
 	closing = false;
+	closeTask;
 	closeEpoch = 0;
 	agentStartedAt;
 	lastAgentExit;
@@ -2537,7 +2445,7 @@ var AcpClient = class {
 		this.terminalManager.updatePermissionPolicy(this.options.permissionMode, this.options.nonInteractivePermissions);
 	}
 	hasLiveConnection() {
-		return this.connection != null && !this.connection.signal.aborted && this.agent != null && isChildProcessRunning(this.agent);
+		return !this.closing && this.connection != null && !this.connection.signal.aborted && this.agent != null && isChildProcessRunning(this.agent);
 	}
 	hasReusableSession(sessionId) {
 		return this.hasLiveConnection() && this.loadedSessionId === sessionId;
@@ -2560,15 +2468,17 @@ var AcpClient = class {
 		}
 		fallback?.abort();
 	}
-	async start() {
+	async start(authority) {
+		assertControlAuthority(authority);
 		if (this.hasLiveConnection()) return;
-		if (this.connection || this.agent) await this.close();
-		const epoch = this.closeEpoch;
+		const epoch = await this.waitForPreviousClose();
 		const maxMessageBytes = readMaxAcpMessageBytes();
-		const launch = await this.resolveAgentLaunchPlan();
+		const launch = await this.resolveAgentLaunchPlan(epoch, authority);
+		this.assertCommandProbeActive(epoch, authority);
 		this.logAgentLaunch(launch);
 		await this.ensureLaunchSupport(launch);
-		const { child, process: startedProcess } = await this.spawnAgentProcess(launch);
+		this.assertCommandProbeActive(epoch, authority);
+		const { child, process: startedProcess } = await this.spawnAgentProcess(launch, authority);
 		if (this.closeEpoch === epoch) {
 			this.agent = child;
 			this.closing = false;
@@ -2591,7 +2501,7 @@ var AcpClient = class {
 			startupFailure.dispose();
 			throw error;
 		}
-		await this.stopIfClosedDuringLaunch(epoch, child, startupFailure);
+		await this.stopIfClosedDuringLaunch(epoch, child, startupFailure, authority);
 		const input = Writable.toWeb(child.stdin);
 		const output = Readable.toWeb(child.stdout);
 		let connection;
@@ -2606,9 +2516,10 @@ var AcpClient = class {
 			elicitationModes: this.options.elicitationModes
 		});
 		connection = this.createConnection(stream, launch, capabilities);
-		connection.signal.addEventListener("abort", () => {
-			this.recordAgentExit(child, "connection_close", child.exitCode ?? null, child.signalCode ?? null);
-		}, { once: true });
+		const onConnectionClose = () => {
+			this.handleAgentDisconnect(child, "connection_close", child.exitCode ?? null, child.signalCode ?? null);
+		};
+		connection.signal.addEventListener("abort", onConnectionClose, { once: true });
 		await this.initializeAgentConnection({
 			child,
 			connection,
@@ -2617,13 +2528,38 @@ var AcpClient = class {
 			launch,
 			capabilities
 		});
+		if (connection.signal.aborted) onConnectionClose();
 	}
-	async resolveAgentLaunchPlan() {
+	async waitForPreviousClose() {
+		const cleanup = this.closeTask ?? (this.connection || this.agent ? this.close() : void 0);
+		const epoch = this.closeEpoch;
+		await cleanup;
+		if (this.closeEpoch !== epoch) throw new Error("ACP client was closed while the agent was starting");
+		return epoch;
+	}
+	async resolveAgentLaunchPlan(epoch, authority) {
 		const configuredCommand = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
 		const resolvedBuiltInLaunch = resolveBuiltInAgentLaunch(this.options.agentCommand);
 		const spawnCommand = resolvedBuiltInLaunch?.command ?? configuredCommand.command;
+		const spawnOptions = buildAgentSpawnOptions(this.options.cwd, this.options.authCredentials, this.options.sessionOptions?.env, this.options.agentProcessEnv);
+		const commandContext = {
+			env: spawnOptions.env,
+			readOutput: async (command, args, timeoutMs, diagnostic = false) => {
+				try {
+					const output = await this.readAgentCommandOutput(command, args, timeoutMs, spawnOptions, epoch, authority);
+					await admitCommandProbe(() => this.assertCommandProbeActive(epoch, authority));
+					return output;
+				} catch (error) {
+					if (error instanceof CommandProbeAdmissionError) {
+						if (diagnostic) return;
+						throw error.reason;
+					}
+					throw error;
+				}
+			}
+		};
 		let args = resolvedBuiltInLaunch?.args ?? configuredCommand.args;
-		args = await resolveGeminiCommandArgs(spawnCommand, args);
+		args = await resolveGeminiCommandArgs(spawnCommand, args, commandContext);
 		if (isQoderAcpCommand(spawnCommand, args)) args = buildQoderAcpCommandArgs(args, this.options);
 		return {
 			spawnCommand,
@@ -2633,7 +2569,8 @@ var AcpClient = class {
 			geminiAcp: isGeminiAcpCommand(spawnCommand, args),
 			copilotAcp: isCopilotAcpCommand(spawnCommand, args),
 			claudeAcp: isClaudeAcpCommand(spawnCommand, args),
-			spawnOptions: buildAgentSpawnOptions(this.options.cwd, this.options.authCredentials, this.options.sessionOptions?.env, this.options.agentProcessEnv)
+			spawnOptions,
+			commandContext
 		};
 	}
 	logAgentLaunch(plan) {
@@ -2649,7 +2586,7 @@ var AcpClient = class {
 		this.log(`spawning agent: ${plan.spawnCommand} ${plan.args.join(" ")}`);
 	}
 	async ensureLaunchSupport(plan) {
-		if (plan.copilotAcp) await ensureCopilotAcpSupport(plan.spawnCommand);
+		if (plan.copilotAcp) await ensureCopilotAcpSupport(plan.spawnCommand, plan.commandContext);
 		if (!plan.claudeAcp) return;
 		const claudeExe = resolveClaudeCodeExecutable(process.platform, plan.spawnOptions.env);
 		if (claudeExe) {
@@ -2657,21 +2594,36 @@ var AcpClient = class {
 			this.log(`resolved system Claude Code executable: ${claudeExe}`);
 		}
 	}
-	async spawnAgentProcess(plan) {
-		const spawnCommand = buildAgentSpawnCommand(plan.spawnCommand, plan.args, process.platform, plan.spawnOptions.env);
-		const launch = Object.freeze({
-			launchId: randomUUID(),
-			scope: snapshotProcessLaunchScope(this.options.processLaunchScope),
-			command: spawnCommand.command,
-			args: Object.freeze([...spawnCommand.args]),
-			cwd: this.options.cwd
+	prepareProcessLaunch(command, args, options) {
+		const resolved = buildAgentSpawnCommand(command, args, process.platform, options.env);
+		return {
+			launch: Object.freeze({
+				launchId: randomUUID(),
+				scope: snapshotProcessLaunchScope(this.options.processLaunchScope),
+				command: resolved.command,
+				args: Object.freeze([...resolved.args]),
+				cwd: options.cwd
+			}),
+			windowsVerbatimArguments: resolved.windowsVerbatimArguments
+		};
+	}
+	startedProcess(launch, pid) {
+		return Object.freeze({
+			...launch,
+			pid,
+			startedAt: isoNow$2()
 		});
+	}
+	async spawnAgentProcess(plan, authority) {
+		const prepared = this.prepareProcessLaunch(plan.spawnCommand, plan.args, plan.spawnOptions);
+		const { launch } = prepared;
 		await this.options.processLifecycle?.onBeforeSpawn?.(launch);
+		assertControlAuthority(authority);
 		let spawnedChild;
 		try {
-			spawnedChild = spawn(spawnCommand.command, spawnCommand.args, {
+			spawnedChild = spawn(launch.command, [...launch.args], {
 				...plan.spawnOptions,
-				windowsVerbatimArguments: spawnCommand.windowsVerbatimArguments
+				windowsVerbatimArguments: prepared.windowsVerbatimArguments
 			});
 			await waitForSpawn(spawnedChild);
 		} catch (error) {
@@ -2690,21 +2642,86 @@ var AcpClient = class {
 		}
 		return {
 			child,
-			process: Object.freeze({
-				...launch,
-				pid,
-				startedAt: isoNow$2()
-			})
+			process: this.startedProcess(launch, pid)
 		};
 	}
+	assertCommandProbeActive(epoch, authority) {
+		assertControlAuthority(authority);
+		if (this.closeEpoch !== epoch) throw new Error("ACP client was closed while the agent was starting");
+	}
+	async readAgentCommandOutput(command, args, timeoutMs, options, epoch, authority) {
+		const prepared = this.prepareProcessLaunch(command, args, options);
+		const { launch } = prepared;
+		await admitCommandProbe(async () => {
+			this.assertCommandProbeActive(epoch, authority);
+			await this.options.processLifecycle?.onBeforeSpawn?.(launch);
+		});
+		try {
+			this.assertCommandProbeActive(epoch, authority);
+		} catch (error) {
+			throw new CommandProbeAdmissionError(error);
+		}
+		let child;
+		try {
+			child = spawn(launch.command, [...launch.args], {
+				cwd: options.cwd,
+				env: options.env,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				windowsHide: true,
+				windowsVerbatimArguments: prepared.windowsVerbatimArguments,
+				detached: process.platform !== "win32"
+			});
+		} catch (error) {
+			this.notifyProcessSpawnFailure(launch, new AgentSpawnError(command, error));
+			return;
+		}
+		this.commandProbes.add(child);
+		this.agentDescendants.set(child, new ProcessDescendants(child, { ownProcessGroup: true }));
+		const capture = captureCommandProbeOutput(child, timeoutMs, () => this.terminateAgentProcess(child));
+		try {
+			try {
+				await waitForSpawn(child);
+			} catch (error) {
+				this.notifyProcessSpawnFailure(launch, new AgentSpawnError(command, error));
+				return;
+			}
+			if (child.pid === void 0) {
+				this.notifyProcessSpawnFailure(launch, new AgentSpawnError(command, /* @__PURE__ */ new Error("spawned probe did not expose a PID")));
+				return;
+			}
+			const started = this.startedProcess(launch, child.pid);
+			await this.admitSpawnedProcess(child, (barrier) => this.attachProcessExitObserver(child, started, barrier), () => admitCommandProbe(async () => {
+				await this.options.processLifecycle?.onSpawned?.(started);
+				this.assertCommandProbeActive(epoch, authority);
+			}));
+			const output = await capture.result;
+			await admitCommandProbe(() => this.assertCommandProbeActive(epoch, authority));
+			return output;
+		} finally {
+			try {
+				await this.terminateAgentProcess(child);
+			} finally {
+				capture.dispose();
+				this.commandProbes.delete(child);
+			}
+		}
+	}
 	async admitAndObserveSpawnedProcess(child, process) {
+		await this.admitSpawnedProcess(child, (barrier) => this.attachAgentLifecycleObservers(child, process, barrier), async () => {
+			await this.options.processLifecycle?.onSpawned?.(process);
+		});
+	}
+	async admitSpawnedProcess(child, observe, admit) {
 		let releaseExitNotification = () => {};
-		const exitNotificationBarrier = new Promise((resolve) => {
+		observe(new Promise((resolve) => {
 			releaseExitNotification = resolve;
-		});
-		this.attachAgentLifecycleObservers(child, process, exitNotificationBarrier);
+		}));
 		try {
-			await this.options.processLifecycle?.onSpawned?.(process);
+			await admit();
 		} catch (error) {
 			await this.terminateAgentProcess(child);
 			throw error;
@@ -2770,7 +2787,7 @@ var AcpClient = class {
 		await this.captureAgentDescendants(params.child);
 		const normalizedError = error instanceof AcpMessageLimitError ? error : await this.normalizeInitializeError(error, params.child, params.startupStderr);
 		await this.terminateAgentProcess(params.child);
-		if (params.launch.geminiAcp && error instanceof TimeoutError) throw new GeminiAcpStartupTimeoutError(await buildGeminiAcpStartupTimeoutMessage(params.launch.spawnCommand), {
+		if (params.launch.geminiAcp && error instanceof TimeoutError) throw new GeminiAcpStartupTimeoutError(await buildGeminiAcpStartupTimeoutMessage(params.launch.spawnCommand, params.launch.commandContext), {
 			cause: error,
 			retryable: true
 		});
@@ -2788,7 +2805,8 @@ var AcpClient = class {
 			onPromptRequestWritten: (active, owner) => this.onPromptRequestWritten(active, owner)
 		});
 	}
-	async createSession(cwd = this.options.cwd) {
+	async createSession(cwd = this.options.cwd, authority) {
+		assertControlAuthority(authority);
 		const connection = this.getConnection();
 		const { command, args } = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
 		const claudeAcp = isClaudeAcpCommand(command, args);
@@ -2799,7 +2817,7 @@ var AcpClient = class {
 				cwd: sessionCwd,
 				mcpServers: this.options.mcpServers ?? [],
 				_meta: buildClaudeCodeOptionsMeta(this.options.sessionOptions, claudeAcp)
-			}));
+			}), authority);
 			result = claudeAcp ? await withTimeout(createPromise, resolveClaudeAcpSessionCreateTimeoutMs()) : await createPromise;
 		} catch (error) {
 			if (claudeAcp && error instanceof TimeoutError) throw new ClaudeAcpSessionCreateTimeoutError(buildClaudeAcpSessionCreateTimeoutMessage(), {
@@ -2831,6 +2849,7 @@ var AcpClient = class {
 	async loadSessionWithOptions(sessionId, cwd = this.options.cwd, options = {}) {
 		const connection = this.getConnection();
 		const sessionCwd = await resolveAgentSessionCwd(cwd, this.options.agentCommand);
+		assertControlAuthority(options.authority);
 		const previousSuppression = this.applySessionUpdateSuppression(Boolean(options.suppressReplayUpdates));
 		let response;
 		try {
@@ -2838,7 +2857,7 @@ var AcpClient = class {
 				sessionId,
 				cwd: sessionCwd,
 				mcpServers: this.options.mcpServers ?? []
-			}));
+			}), options.authority);
 			await this.waitForSessionUpdateDrain(options.replayIdleMs ?? REPLAY_IDLE_MS, options.replayDrainTimeoutMs ?? REPLAY_DRAIN_TIMEOUT_MS);
 		} finally {
 			this.restoreSessionUpdateSuppression(previousSuppression);
@@ -2848,14 +2867,15 @@ var AcpClient = class {
 		await this.captureAgentDescendants(this.agent);
 		return result;
 	}
-	async resumeSession(sessionId, cwd = this.options.cwd) {
+	async resumeSession(sessionId, cwd = this.options.cwd, authority) {
+		assertControlAuthority(authority);
 		const connection = this.getConnection();
 		const sessionCwd = await resolveAgentSessionCwd(cwd, this.options.agentCommand);
 		const response = await this.runConnectionRequest(() => connection.agent.request(methods.agent.session.resume, {
 			sessionId,
 			cwd: sessionCwd,
 			mcpServers: this.options.mcpServers ?? []
-		}));
+		}), authority);
 		this.loadedSessionId = sessionId;
 		const result = toReconnectedSessionResult(response);
 		await this.captureAgentDescendants(this.agent);
@@ -2877,7 +2897,6 @@ var AcpClient = class {
 	async prompt(sessionId, prompt, onRequestWritten, onElicitation, onPermissionRequest, authority) {
 		const connection = this.getConnection();
 		const normalizedPrompt = this.normalizePromptForAgent(prompt);
-		const restoreConsoleError = this.options.suppressSdkConsoleErrors ? installSdkConsoleErrorSuppression() : void 0;
 		const previousActivePrompt = this.activePrompt;
 		const replacedOwners = this.pendingPromptOwners.filter((owner) => owner.sessionId === sessionId);
 		const activePrompt = this.beginActivePrompt(sessionId, onRequestWritten, onElicitation, onPermissionRequest, authority);
@@ -2895,7 +2914,6 @@ var AcpClient = class {
 			this.throwPromptPermissionFailureIfPresent(sessionId);
 			throw error;
 		} finally {
-			restoreConsoleError?.();
 			this.clearActivePrompt(activePrompt);
 		}
 	}
@@ -3080,20 +3098,23 @@ var AcpClient = class {
 			if (timer) clearTimeout(timer);
 		}
 	}
-	async close() {
+	close() {
 		this.closing = true;
 		this.closeEpoch += 1;
+		if (this.closeTask) return this.closeTask;
+		this.closeTask = Promise.resolve().then(() => this.finishClose()).finally(() => {
+			this.closeTask = void 0;
+		});
+		return this.closeTask;
+	}
+	async finishClose() {
 		const permissionControllers = [...this.permissionAbortControllers.values()];
 		this.permissionAbortControllers.clear();
 		const owners = [...this.pendingPromptOwners];
 		this.abortActiveElicitation();
 		for (const owner of owners) owner.requestController.abort();
 		for (const controller of permissionControllers) controller.abort();
-		await this.terminalManager.shutdown();
-		const agent = this.agent;
-		if (agent) await this.terminateAgentProcess(agent);
-		this.closeConnection();
-		if (this.pendingConnectionRequests.size > 0) this.rejectPendingConnectionRequests(this.lastAgentExit ? new AgentDisconnectedError(this.lastAgentExit.reason, this.lastAgentExit.exitCode, this.lastAgentExit.signal, { outputAlreadyEmitted: Boolean(this.activePrompt) }) : new AgentDisconnectedError("connection_close", null, null, { outputAlreadyEmitted: Boolean(this.activePrompt) }));
+		await this.retireNativeResources();
 		this.sessionUpdateChain = Promise.resolve();
 		this.observedSessionUpdates = 0;
 		this.processedSessionUpdates = 0;
@@ -3110,10 +3131,28 @@ var AcpClient = class {
 		this.connection = void 0;
 		this.agent = void 0;
 	}
-	async stopIfClosedDuringLaunch(epoch, child, startupFailure) {
+	async retireNativeResources() {
+		const owned = [...this.commandProbes, ...this.agent ? [this.agent] : []];
+		const failures = [];
+		try {
+			await this.terminalManager.shutdown();
+		} catch (error) {
+			failures.push(error);
+		}
+		const retired = await Promise.allSettled(owned.map((child) => this.terminateAgentProcess(child)));
+		for (const result of retired) if (result.status === "rejected") failures.push(result.reason);
+		try {
+			this.closeConnection();
+		} finally {
+			this.rejectPendingConnectionRequests(this.lastAgentExit ? new AgentDisconnectedError(this.lastAgentExit.reason, this.lastAgentExit.exitCode, this.lastAgentExit.signal, { outputAlreadyEmitted: Boolean(this.activePrompt) }) : new AgentDisconnectedError("connection_close", null, null, { outputAlreadyEmitted: Boolean(this.activePrompt) }));
+		}
+		if (failures.length > 0) throw new AggregateError(failures, "ACP client cleanup failed", { cause: failures[0] });
+	}
+	async stopIfClosedDuringLaunch(epoch, child, startupFailure, authority) {
 		if (this.closeEpoch === epoch) return;
 		startupFailure.dispose();
 		await this.terminateAgentProcess(child);
+		assertControlAuthority(authority);
 		throw new Error("ACP client was closed while the agent was starting");
 	}
 	abortActiveElicitation() {
@@ -3127,6 +3166,11 @@ var AcpClient = class {
 		if (descendants && !await descendants.capture()) this.log("could not verify agent descendants; skipping unverified process cleanup");
 	}
 	terminateAgentProcess(child) {
+		if (child.pid === void 0) {
+			this.agentDescendants.get(child)?.retire();
+			this.detachAgentHandles(child, true);
+			return Promise.resolve();
+		}
 		let cleanup = this.agentCleanups.get(child);
 		if (!cleanup) {
 			cleanup = Promise.resolve().then(() => this.cleanupAgentProcess(child));
@@ -3136,12 +3180,12 @@ var AcpClient = class {
 	}
 	async cleanupAgentProcess(child) {
 		const descendants = this.agentDescendants.get(child);
-		const deadline = Date.now() + AGENT_CLEANUP_BUDGET_MS;
+		const deadline = performance.now() + AGENT_CLEANUP_BUDGET_MS;
 		const stdinCloseGraceMs = resolveAgentCloseAfterStdinEndMs(this.options.agentCommand);
 		try {
-			if (descendants) await descendants.capture(Math.max(1, deadline - Date.now()));
+			if (descendants) await descendants.capture(Math.max(1, deadline - performance.now()));
 			this.endAgentStdin(child);
-			await waitForChildExit(child, Math.min(stdinCloseGraceMs, Math.max(0, deadline - Date.now())));
+			await waitForChildExit(child, Math.min(stdinCloseGraceMs, Math.max(0, deadline - performance.now())));
 			if (!await this.signalAgentAndDescendants(child, "SIGTERM", AGENT_CLOSE_TERM_GRACE_MS, deadline)) {
 				this.log("agent processes did not exit after SIGTERM; forcing SIGKILL");
 				await this.signalAgentAndDescendants(child, "SIGKILL", AGENT_CLOSE_KILL_GRACE_MS, deadline);
@@ -3152,18 +3196,18 @@ var AcpClient = class {
 		}
 	}
 	endAgentStdin(child) {
-		if (child.stdin.destroyed) return;
+		if (!child.stdin || child.stdin.destroyed) return;
 		try {
 			child.stdin.end();
 		} catch {}
 	}
 	async signalAgentAndDescendants(child, signal, waitMs, deadline) {
 		const descendants = this.agentDescendants.get(child);
-		if (descendants && Date.now() < deadline) await descendants.signal(signal, deadline - Date.now());
+		if (descendants && performance.now() < deadline) await descendants.signal(signal, deadline - performance.now());
 		if (isChildProcessRunning(child)) try {
 			child.kill(signal);
 		} catch {}
-		const remaining = Math.min(waitMs, Math.max(0, deadline - Date.now()));
+		const remaining = Math.min(waitMs, Math.max(0, deadline - performance.now()));
 		const [exited, descendantsExited] = await Promise.all([waitForChildExit(child, remaining), descendants ? descendants.waitForExit(remaining) : Promise.resolve(true)]);
 		return exited && descendantsExited;
 	}
@@ -3473,24 +3517,34 @@ var AcpClient = class {
 		return cancelledPermissionResponse();
 	}
 	attachAgentLifecycleObservers(child, startedProcess, exitNotificationBarrier) {
+		this.attachProcessExitObserver(child, startedProcess, exitNotificationBarrier, (exitCode, signal) => {
+			this.handleAgentDisconnect(child, "process_exit", exitCode, signal);
+			this.terminateAgentProcess(child);
+		});
+		child.once("close", (exitCode, signal) => {
+			this.handleAgentDisconnect(child, "process_close", exitCode, signal);
+		});
+		child.stdout.once("close", () => {
+			this.handleAgentDisconnect(child, "pipe_close", child.exitCode ?? null, child.signalCode ?? null);
+		});
+	}
+	attachProcessExitObserver(child, started, barrier, onProcessExit) {
 		const onExit = (exitCode, signal) => {
 			const exitedAt = isoNow$2();
-			this.recordAgentExit(child, "process_exit", exitCode, signal);
-			this.terminateAgentProcess(child);
-			exitNotificationBarrier.then(() => {
-				this.notifyProcessExit(startedProcess, exitCode, signal, exitedAt);
-			});
+			onProcessExit?.(exitCode, signal);
+			barrier.then(() => this.notifyProcessExit(started, exitCode, signal, exitedAt));
 		};
 		child.once("exit", onExit);
 		if (child.exitCode !== null || child.signalCode !== null) {
 			child.off("exit", onExit);
 			onExit(child.exitCode, child.signalCode);
 		}
-		child.once("close", (exitCode, signal) => {
-			this.recordAgentExit(child, "process_close", exitCode, signal);
-		});
-		child.stdout.once("close", () => {
-			this.recordAgentExit(child, "pipe_close", child.exitCode ?? null, child.signalCode ?? null);
+	}
+	handleAgentDisconnect(child, reason, exitCode, signal) {
+		this.recordAgentExit(child, reason, exitCode, signal);
+		if (this.agent !== child || this.closing || !this.connection) return;
+		this.close().catch((error) => {
+			this.log(`disconnected agent cleanup failed: ${String(error)}`);
 		});
 	}
 	notifyProcessSpawnFailure(launch, error) {
@@ -3854,7 +3908,6 @@ function ensureAgentMessage(conversation) {
 	return created;
 }
 function appendAgentText(agent, text) {
-	if (!text.trim()) return;
 	const last = agent.content.at(-1);
 	if (last && isAgentTextContent(last)) {
 		last.Text = trimRuntimeText(`${last.Text}${text}`, MAX_RUNTIME_AGENT_TEXT_CHARS);
@@ -3864,7 +3917,6 @@ function appendAgentText(agent, text) {
 	agent.content.push(next);
 }
 function appendAgentThinking(agent, text) {
-	if (!text.trim()) return;
 	const last = agent.content.at(-1);
 	if (last && isAgentThinkingContent(last)) {
 		last.Thinking.text = trimRuntimeText(`${last.Thinking.text}${text}`, MAX_RUNTIME_THINKING_CHARS);
@@ -3921,8 +3973,7 @@ function ensureToolUseContent(agent, toolCallId) {
 	return created;
 }
 function upsertToolResult(agent, toolCallId, patch) {
-	const existing = agent.tool_results[toolCallId];
-	const fallback = existingToolResultValues(existing);
+	const fallback = existingToolResultValues(hasOwn(agent.tool_results, toolCallId) ? agent.tool_results[toolCallId] : void 0);
 	const next = {
 		tool_use_id: toolCallId,
 		tool_name: patch.tool_name ?? fallback.tool_name,
@@ -3930,7 +3981,12 @@ function upsertToolResult(agent, toolCallId, patch) {
 		content: patch.content ?? fallback.content,
 		output: patch.output ?? fallback.output
 	};
-	agent.tool_results[toolCallId] = next;
+	Object.defineProperty(agent.tool_results, toolCallId, {
+		value: next,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
 }
 function existingToolResultValues(existing) {
 	if (existing) return existing;
@@ -3971,7 +4027,7 @@ function applyToolResultUpdate(agent, tool, update) {
 	const output = hasOwn(update, "rawOutput") ? deepClone(update.rawOutput) : void 0;
 	upsertToolResult(agent, update.toolCallId, {
 		tool_name: tool.name,
-		is_error: statusIndicatesError(status),
+		is_error: status === void 0 ? void 0 : statusIndicatesError(status),
 		content: output === void 0 ? void 0 : toToolResultContent(output),
 		output
 	});
@@ -4301,6 +4357,11 @@ function mergeSessionOptions(preferred, fallback) {
 	assignDefinedOption(merged, "env", mergeEnvRecords(fallback?.env, preferred?.env));
 	return Object.keys(merged).length > 0 ? merged : void 0;
 }
+function normalizeSessionOptionShape(options) {
+	const normalized = mergeSessionOptions(options, void 0);
+	if (normalized?.env !== void 0 && Object.keys(normalized.env).length === 0) delete normalized.env;
+	return normalized && Object.keys(normalized).length > 0 ? normalized : void 0;
+}
 function mergeEnvRecords(fallback, preferred) {
 	if (!fallback && !preferred) return;
 	return {
@@ -4397,10 +4458,7 @@ function getDesiredModeId(state) {
 function getDesiredConfigOptions(state) {
 	const desired = state?.desired_config_options;
 	if (!desired) return {};
-	return Object.fromEntries(Object.entries(desired).flatMap(([configId, value]) => {
-		const normalizedConfigId = normalizeModeId(configId);
-		return normalizedConfigId && typeof value === "string" ? [[normalizedConfigId, value]] : [];
-	}));
+	return Object.fromEntries(Object.entries(desired).filter(([, value]) => typeof value === "string"));
 }
 function setDesiredModeId(record, modeId) {
 	const acpx = ensureAcpxState(record.acpx);
@@ -4410,10 +4468,9 @@ function setDesiredModeId(record, modeId) {
 	record.acpx = acpx;
 }
 function clearDesiredConfigOption(state, configId) {
-	const normalizedConfigId = normalizeModeId(configId);
-	if (!normalizedConfigId || !state.desired_config_options) return;
+	if (typeof configId !== "string" || !state.desired_config_options) return;
 	const desired = { ...state.desired_config_options };
-	delete desired[normalizedConfigId];
+	delete desired[configId];
 	if (Object.keys(desired).length > 0) state.desired_config_options = desired;
 	else delete state.desired_config_options;
 }
@@ -4452,7 +4509,7 @@ async function applyRequestedModelIfAdvertised(params) {
 	if (params.models.currentModelId === requestedModel) return { applied: true };
 	return {
 		applied: true,
-		response: await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, params.models), params.timeoutMs)
+		response: await withTimeout(params.client.setSessionModel(params.sessionId, requestedModel, params.models, params.authority), params.timeoutMs)
 	};
 }
 //#endregion
@@ -4477,9 +4534,9 @@ function applyAcceptedConfigOptions(state, response) {
 	if (!response) return next;
 	applyConfigOptionsModelState(next, response.configOptions);
 	if (!next.desired_config_options) return next;
-	const desired = {};
-	for (const option of response.configOptions) if (typeof option.currentValue === "string" && Object.hasOwn(next.desired_config_options, option.id)) desired[option.id] = option.currentValue;
-	if (Object.keys(desired).length > 0) next.desired_config_options = desired;
+	const desiredEntries = [];
+	for (const option of response.configOptions) if (typeof option.currentValue === "string" && Object.hasOwn(next.desired_config_options, option.id)) desiredEntries.push([option.id, option.currentValue]);
+	if (desiredEntries.length > 0) next.desired_config_options = Object.fromEntries(desiredEntries);
 	else delete next.desired_config_options;
 	return next;
 }
@@ -4497,8 +4554,7 @@ function applyModelSelection(state, modelId, response) {
 function applyConfigOptionSelection(state, configId, value, response, modelConfigId = advertisedModelState(state)?.configId) {
 	if (configId === modelConfigId || configId === modelStateFromConfigOptions(response.configOptions)?.configId) return applyModelSelection(state, value, response);
 	const next = cloneSessionAcpxState(state) ?? {};
-	if (configId === "mode") next.desired_mode_id = value;
-	else next.desired_config_options = {
+	next.desired_config_options = {
 		...next.desired_config_options,
 		[configId]: value
 	};
@@ -4509,6 +4565,7 @@ function applyConfigOptionSelection(state, configId, value, response, modelConfi
 const LOCK_RETRY_MS = 15;
 const INCOMPLETE_RESERVATION_GRACE_MS = 15e3;
 let lastCreatedAt = 0;
+const localTurns = /* @__PURE__ */ new Map();
 async function readLock(filePath) {
 	try {
 		const stat = await fs$1.lstat(filePath, { bigint: true });
@@ -4522,11 +4579,6 @@ async function readLock(filePath) {
 		throw error;
 	}
 }
-function lockPid(value) {
-	if (!value || typeof value !== "object" || !("pid" in value)) return;
-	const pid = value.pid;
-	return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
-}
 function parseLock(payload) {
 	try {
 		return JSON.parse(payload);
@@ -4534,7 +4586,7 @@ function parseLock(payload) {
 		return;
 	}
 }
-async function tryAcquireGuard(filePath) {
+async function tryAcquireGuard(filePath, owner, signal) {
 	try {
 		return await acquireFileLock(filePath, {
 			managerKey: "acpx.session-turn",
@@ -4549,9 +4601,9 @@ async function tryAcquireGuard(filePath) {
 				randomize: false
 			},
 			staleRecovery: "remove-if-unchanged",
-			payload: () => ({ pid: process.pid }),
-			shouldReclaim: ({ payload }) => isProcessDefinitelyDead(lockPid(payload)),
-			shouldRemoveStaleLock: ({ payload }) => isProcessDefinitelyDead(lockPid(payload))
+			payload: () => owner.payload,
+			shouldReclaim: ({ payload }) => owner.hasExited(payload, false, signal),
+			shouldRemoveStaleLock: ({ payload }) => owner.hasExited(payload, true, signal)
 		});
 	} catch (error) {
 		if (error.code === "file_lock_timeout") return;
@@ -4567,11 +4619,12 @@ async function removeObservedLock(filePath, observed) {
 	});
 	return true;
 }
-async function recoverAbandonedLock(filePath) {
+async function recoverAbandonedLock(filePath, owner, signal) {
 	const observed = await readLock(filePath);
 	if (!observed) return true;
-	const pid = lockPid(parseLock(observed.payload));
-	if (pid && !isProcessDefinitelyDead(pid)) return false;
+	const payload = parseLock(observed.payload);
+	const pid = lockOwnerPid(payload);
+	if (pid && (!await owner.hasExited(payload, false, signal) || !await owner.hasExited(payload, true, signal))) return false;
 	if (!pid && Date.now() - Number(observed.stat.mtimeMs) <= INCOMPLETE_RESERVATION_GRACE_MS) return false;
 	if (await removeObservedLock(filePath, observed)) {
 		incrementPerfCounter("session.events.stale_lock_recovered");
@@ -4607,58 +4660,112 @@ async function removePublishedLock(filePath, payload) {
 	const current = await readLock(filePath);
 	if (current?.payload === payload) await removeObservedLock(filePath, current);
 }
-async function rejectAcquisition(filePath, payload, guard, error) {
+async function rejectAcquisition(filePath, receipt, error) {
 	const failures = [error];
-	await removePublishedLock(filePath, payload).catch((cleanupError) => {
-		failures.push(cleanupError);
-	});
-	await guard.release().catch((releaseError) => {
-		failures.push(releaseError);
+	await disposeTurn(filePath, receipt).catch((cleanupError) => {
+		failures.push(...cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError]);
 	});
 	if (failures.length > 1) throw new AggregateError(failures, "Session turn acquisition and cleanup failed");
 	throw error;
 }
-function turnReceipt(filePath, observed, guard) {
-	let disposed = false;
-	let disposal;
-	return { [Symbol.asyncDispose]: async () => {
-		if (disposed) return;
-		const pending = disposal ??= (async () => {
-			await removeObservedLock(filePath, observed);
-			await guard.release();
-			disposed = true;
-		})();
+async function releaseTurnGuard(receipt) {
+	await receipt.guard?.release();
+	receipt.guard = void 0;
+}
+async function removeTurnMarker(filePath, receipt) {
+	if (!receipt.removeMarker) return true;
+	if (receipt.guard && !await receipt.guard.verifyStillHeld()) await releaseTurnGuard(receipt);
+	receipt.guard ??= await tryAcquireGuard(filePath, receipt.owner);
+	if (!receipt.guard) return false;
+	await receipt.removeMarker();
+	receipt.removeMarker = void 0;
+	return true;
+}
+async function settleTurn(filePath, receipt) {
+	if (receipt.settled) return true;
+	const pending = receipt.pending ??= (async () => {
+		receipt.failed = false;
+		const failures = [];
 		try {
-			await pending;
-		} finally {
-			if (disposal === pending) disposal = void 0;
+			if (!await removeTurnMarker(filePath, receipt)) return false;
+		} catch (error) {
+			failures.push(error);
 		}
-	} };
+		if (failures.length === 0 || !receipt.admitted) try {
+			await releaseTurnGuard(receipt);
+		} catch (error) {
+			failures.push(error);
+		}
+		if (failures.length > 1) throw new AggregateError(failures, "Session turn cleanup failed");
+		if (failures.length === 1) throw failures[0];
+		receipt.settled = true;
+		localTurns.delete(filePath);
+		return true;
+	})();
+	try {
+		return await pending;
+	} finally {
+		if (receipt.pending === pending) {
+			receipt.pending = void 0;
+			receipt.failed = !receipt.settled;
+		}
+	}
 }
-async function tryPublishLock(filePath, payload, signal) {
+async function disposeTurn(filePath, receipt) {
+	if (!await settleTurn(filePath, receipt)) throw new Error(`Session turn cleanup is waiting for its guard: ${filePath}`);
+}
+async function tryPublishLock(filePath, payload, owner, signal) {
 	for (;;) try {
 		await publishLock(filePath, payload, signal);
 		return true;
 	} catch (error) {
 		if (error.code !== "EEXIST") throw error;
-		if (!await recoverAbandonedLock(filePath)) return false;
+		if (!await recoverAbandonedLock(filePath, owner, signal)) return false;
 	}
 }
-async function tryAcquireTurn(filePath, payload, signal) {
-	const guard = await tryAcquireGuard(filePath);
-	if (!guard) return;
+async function tryAcquireTurnCleanup(filePath, payload, owner, signal) {
+	const previous = localTurns.get(filePath);
+	if (previous) {
+		if (previous.failed) await settleTurn(filePath, previous);
+		return;
+	}
+	const receipt = {
+		owner,
+		removeMarker: async () => await removePublishedLock(filePath, payload),
+		admitted: false,
+		failed: false,
+		settled: false
+	};
+	localTurns.set(filePath, receipt);
+	try {
+		receipt.guard = await tryAcquireGuard(filePath, owner, signal);
+	} catch (error) {
+		localTurns.delete(filePath);
+		throw error;
+	}
+	if (!receipt.guard) {
+		localTurns.delete(filePath);
+		return;
+	}
+	return receipt;
+}
+async function tryAcquireTurn(filePath, payload, owner, signal) {
+	const receipt = await tryAcquireTurnCleanup(filePath, payload, owner, signal);
+	if (!receipt) return;
 	try {
 		signal?.throwIfAborted();
-		if (!await tryPublishLock(filePath, payload, signal)) {
-			await guard.release();
+		if (!await tryPublishLock(filePath, payload, owner, signal)) {
+			await disposeTurn(filePath, receipt);
 			return;
 		}
 		const observed = await readLock(filePath);
 		if (observed?.payload !== payload) throw new Error(`Session turn ownership changed before admission: ${filePath}`);
 		signal?.throwIfAborted();
-		return turnReceipt(filePath, observed, guard);
+		receipt.admitted = true;
+		receipt.removeMarker = async () => await removeObservedLock(filePath, observed);
+		return { [Symbol.asyncDispose]: async () => await disposeTurn(filePath, receipt) };
 	} catch (error) {
-		return await rejectAcquisition(filePath, payload, guard, error);
+		return await rejectAcquisition(filePath, receipt, error);
 	}
 }
 async function acquireSessionTurn(recordId, signal) {
@@ -4668,19 +4775,44 @@ async function acquireSessionTurn(recordId, signal) {
 		mode: 448
 	});
 	const filePath = path.join(await fs$1.realpath(path.dirname(requestedPath)), path.basename(requestedPath));
+	const owner = await createLockOwner({ signal });
 	lastCreatedAt = Math.max(Date.now(), lastCreatedAt + 1);
 	const payload = `${JSON.stringify({
-		pid: process.pid,
+		...owner.payload,
 		created_at: new Date(lastCreatedAt).toISOString()
 	}, null, 2)}\n`;
 	for (;;) {
 		signal?.throwIfAborted();
-		const turn = await tryAcquireTurn(filePath, payload, signal);
+		const turn = await tryAcquireTurn(filePath, payload, owner, signal);
 		if (turn) return turn;
 		await setTimeout$1(LOCK_RETRY_MS, void 0, { signal });
 	}
 }
 //#endregion
+//#region src/session/execution/direct-lifetime.ts
+function ownDirectClient(client, signal) {
+	let closing;
+	const cancel = async () => {
+		await withTimeout(client.cancelActivePrompt(2500), 2500).catch(() => {});
+		await client.close();
+	};
+	const onAbort = () => {
+		closing ??= cancel();
+		closing.catch(() => {});
+	};
+	signal?.addEventListener("abort", onAbort, { once: true });
+	if (signal?.aborted) onAbort();
+	const release = () => signal?.removeEventListener("abort", onAbort);
+	return Object.assign(() => {
+		release();
+		closing ??= client.close();
+		return closing;
+	}, { release });
+}
+function directExecutionError(error, signal) {
+	return signal?.aborted && error instanceof AgentDisconnectedError ? signal.reason : error;
+}
+//#endregion
 //#region src/session/queue/ipc-server.ts
 const QUEUE_SOCKET_DRAIN_TIMEOUT_MS = 1e3;
 function makeQueueOwnerError(requestId, message, detailCode, options = {}) {
@@ -4713,9 +4845,12 @@ function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options =
 		acp: normalized.acp
 	};
 }
+function armSocketDrainTimeout(socket) {
+	if (process.platform !== "win32") socket.setTimeout(QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
+}
 function writeQueueMessage(socket, message) {
 	if (socket.destroyed || !socket.writable) return;
-	socket.write(`${JSON.stringify(message)}\n`);
+	if (!socket.write(`${JSON.stringify(message)}\n`) && !socket.timeout) armSocketDrainTimeout(socket);
 }
 var SessionQueueOwner = class SessionQueueOwner {
 	server;
@@ -4883,6 +5018,7 @@ var SessionQueueOwner = class SessionQueueOwner {
 		if (socket.destroyed || this.drainingSockets.has(socket)) return;
 		this.taskSockets.delete(socket);
 		this.drainingSockets.add(socket);
+		armSocketDrainTimeout(socket);
 		socket.end(() => {
 			this.drainingSockets.delete(socket);
 			socket.destroy();
@@ -5032,6 +5168,10 @@ var SessionQueueOwner = class SessionQueueOwner {
 	handleConnection(socket) {
 		this.sockets.add(socket);
 		socket.setEncoding("utf8");
+		socket.on("timeout", () => socket.destroy());
+		socket.on("drain", () => {
+			if (!socket.writableEnded) socket.setTimeout(0);
+		});
 		socket.once("close", () => {
 			this.sockets.delete(socket);
 			this.taskSockets.delete(socket);
@@ -5120,6 +5260,10 @@ async function replayDesiredMode(params) {
 		await withTimeout(params.client.setSessionMode(params.sessionId, params.desiredModeId, params.replay.authority), params.timeoutMs);
 		params.replay.acknowledged = true;
 		if (params.verbose) process.stderr.write(`[acpx] replayed desired mode ${params.desiredModeId} on fresh ACP session ${params.sessionId} (previous ${params.previousSessionId})\n`);
+		return {
+			models: advertisedModelState(params.record.acpx),
+			configOptionsPresent: params.record.acpx?.config_options !== void 0
+		};
 	} catch (error) {
 		rethrowAuthorityFailure(params.replay, error);
 		throw new SessionModeReplayError(`Failed to replay saved session mode ${params.desiredModeId} on fresh ACP session ${params.sessionId}: ${formatErrorMessage(error)}`, {
@@ -5198,18 +5342,20 @@ function restoreOriginalSessionState(params) {
 async function connectAndLoadSession(options) {
 	const record = options.record;
 	const client = options.client;
+	assertControlAuthority(options.authority);
 	const sameSessionOnly = requiresSameSession(options.resumePolicy) || Boolean(record.importedFrom);
 	const originalSessionId = record.acpSessionId;
 	const originalAgentSessionId = record.agentSessionId;
 	const originalAcpx = cloneSessionAcpxState(record.acpx);
-	const desiredModeId = getDesiredModeId(record.acpx);
+	const desiredModeId = options.replacingMode ? void 0 : getDesiredModeId(record.acpx);
 	const desiredModelId = getDesiredModelId(record.acpx);
 	const desiredConfigOptions = getDesiredConfigOptions(record.acpx);
 	const storedProcessAlive = isProcessAlive(record.pid);
 	logReconnectAttempt(record, storedProcessAlive, Boolean(record.pid) && !storedProcessAlive, options.verbose);
 	const reusingLoadedSession = client.hasReusableSession(record.acpSessionId);
 	if (reusingLoadedSession) incrementPerfCounter("runtime.connect_and_load.reused_session");
-	else await withTimeout(client.start(), options.timeoutMs);
+	else await withTimeout(client.start(options.authority), options.timeoutMs);
+	assertControlAuthority(options.authority);
 	options.onClientAvailable?.(options.activeController);
 	applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 	record.closed = false;
@@ -5220,7 +5366,8 @@ async function connectAndLoadSession(options) {
 		record,
 		reusingLoadedSession,
 		sameSessionOnly,
-		timeoutMs: options.timeoutMs
+		timeoutMs: options.timeoutMs,
+		authority: options.authority
 	});
 	const { resumed, loadError, sessionId, createdFreshSession, pendingAgentSessionId, sessionModels } = loadState;
 	applyReconnectedModelState(record, sessionModels, loadState.configOptionsPresent, loadState.legacyModelMetadataPresent, createdFreshSession);
@@ -5254,14 +5401,18 @@ async function connectAndLoadSession(options) {
 	};
 }
 function resolveModelsAfterReplay(replay, initialModels) {
-	if (replay.configReplay.replayed) return replay.configReplay.models ?? preserveLegacyModels(replay.modelReplay.replayed ? replay.modelReplay.models : initialModels);
-	return replay.modelReplay.replayed ? replay.modelReplay.models : initialModels;
+	const models = resolveModeReplayModels(replay.modeMetadata, initialModels);
+	if (replay.configReplay.replayed) return replay.configReplay.models ?? preserveLegacyModels(replay.modelReplay.replayed ? replay.modelReplay.models : models);
+	return replay.modelReplay.replayed ? replay.modelReplay.models : models;
+}
+function resolveModeReplayModels(modeMetadata, initialModels) {
+	return modeMetadata ? modeMetadata.models : initialModels;
 }
 function preserveLegacyModels(models) {
 	return models && !models.configId ? models : void 0;
 }
 function resolveConfigOptionsPresenceAfterReplay(replay, initiallyPresent) {
-	return initiallyPresent || replay.configReplay.replayed || replay.modelReplay.configOptions !== void 0;
+	return initiallyPresent || replay.modeMetadata?.configOptionsPresent === true || replay.configReplay.replayed || replay.modelReplay.configOptions !== void 0;
 }
 function applyReconnectedModelState(record, sessionModels, configOptionsPresent, legacyModelMetadataPresent, createdFreshSession) {
 	clearOmittedFreshSessionConfigOptions(record, createdFreshSession, configOptionsPresent);
@@ -5302,12 +5453,13 @@ async function replaySessionPreferences(params) {
 	};
 	let modelReplay = { replayed: false };
 	let configReplay = { replayed: false };
+	let modeMetadata;
 	const replay = createReplayState(params.authority);
-	const replacingModel = replacesModel(params.replacingConfigOption, params.sessionModels, params.originalAcpx);
 	try {
 		assertControlAuthority(replay.authority);
-		await replayDesiredMode({
+		modeMetadata = await replayDesiredMode({
 			client: params.client,
+			record: params.record,
 			sessionId: params.sessionId,
 			desiredModeId: params.createdFreshSession ? params.desiredModeId : void 0,
 			replay,
@@ -5315,6 +5467,8 @@ async function replaySessionPreferences(params) {
 			timeoutMs: params.timeoutMs,
 			verbose: params.verbose
 		});
+		const effectiveModels = resolveModeReplayModels(modeMetadata, params.sessionModels);
+		const replacingModel = replacesModel(params.replacingConfigOption, effectiveModels, params.originalAcpx);
 		modelReplay = await replayDesiredModel({
 			client: params.client,
 			sessionId: params.sessionId,
@@ -5322,7 +5476,7 @@ async function replaySessionPreferences(params) {
 			replay,
 			previousSessionId: params.originalSessionId,
 			record: params.record,
-			models: params.sessionModels,
+			models: effectiveModels,
 			createdFreshSession: params.createdFreshSession,
 			timeoutMs: params.timeoutMs,
 			verbose: params.verbose,
@@ -5349,7 +5503,8 @@ async function replaySessionPreferences(params) {
 	reconcileAgentSessionId(params.record, params.pendingAgentSessionId);
 	return {
 		modelReplay,
-		configReplay
+		configReplay,
+		modeMetadata
 	};
 }
 function settleFailedReplay(params, replay, error) {
@@ -5381,11 +5536,14 @@ async function loadOrCreateRuntimeSession(params) {
 		record: params.record,
 		reason: "agent does not support session/resume or session/load"
 	});
-	return await createFreshRuntimeSession(params.client, params.record, params.timeoutMs);
+	return await createFreshRuntimeSession(params.client, params.record, params.timeoutMs, params.authority);
 }
 async function loadRuntimeSession(params, resume) {
 	try {
-		const loadResult = await withTimeout(resume ? params.client.resumeSession(params.record.acpSessionId, params.record.cwd) : params.client.loadSessionWithOptions(params.record.acpSessionId, params.record.cwd, { suppressReplayUpdates: true }), params.timeoutMs);
+		const loadResult = await withTimeout(resume ? params.client.resumeSession(params.record.acpSessionId, params.record.cwd, params.authority) : params.client.loadSessionWithOptions(params.record.acpSessionId, params.record.cwd, {
+			suppressReplayUpdates: true,
+			...params.authority ? { authority: params.authority } : {}
+		}), params.timeoutMs);
 		reconcileAgentSessionId(params.record, loadResult.agentSessionId);
 		applyConfigOptionsToRecord(params.record, loadResult);
 		return {
@@ -5398,9 +5556,14 @@ async function loadRuntimeSession(params, resume) {
 			createdFreshSession: false
 		};
 	} catch (error) {
+		rethrowCancelledLoad(error, params.authority);
 		return await recoverRuntimeSessionLoadFailure(params, error);
 	}
 }
+function rethrowCancelledLoad(error, authority) {
+	const signal = authority?.signal;
+	if (signal?.aborted && (error instanceof AgentDisconnectedError || error === signal.reason)) throw signal.reason;
+}
 async function recoverRuntimeSessionLoadFailure(params, error) {
 	const loadError = formatErrorMessage(error);
 	if (params.sameSessionOnly) throw makeSessionResumeRequiredError({
@@ -5410,12 +5573,12 @@ async function recoverRuntimeSessionLoadFailure(params, error) {
 	});
 	if (!shouldFallbackToNewSession(error, params.record)) throw error;
 	return {
-		...await createFreshRuntimeSession(params.client, params.record, params.timeoutMs),
+		...await createFreshRuntimeSession(params.client, params.record, params.timeoutMs, params.authority),
 		loadError
 	};
 }
-async function createFreshRuntimeSession(client, record, timeoutMs) {
-	const createdSession = await withTimeout(client.createSession(record.cwd), timeoutMs);
+async function createFreshRuntimeSession(client, record, timeoutMs, authority) {
+	const createdSession = await withTimeout(client.createSession(record.cwd, authority), timeoutMs);
 	applyConfigOptionsToRecord(record, createdSession);
 	return {
 		sessionId: createdSession.sessionId,
@@ -5482,6 +5645,7 @@ async function withConnectedSession(options) {
 				client,
 				record,
 				resumePolicy: options.resumePolicy,
+				replacingMode: options.replacingMode,
 				replacingConfigOption: options.replacingConfigOption,
 				authority: options.authority,
 				timeoutMs: options.timeoutMs,
@@ -5542,6 +5706,7 @@ async function withConnectedSession(options) {
 function buildDirectConnectedSessionOptions(options, run) {
 	return {
 		sessionRecordId: options.sessionRecordId,
+		replacingMode: options.replacingMode,
 		replacingConfigOption: options.replacingConfigOption,
 		loadRecord: resolveSessionRecord,
 		saveRecord: writeSessionRecord,
@@ -5592,7 +5757,10 @@ async function withOwnedDirectSession(options) {
 	}
 }
 async function runSessionSetModeDirect(options) {
-	return toSessionMutationResult(await withOwnedDirectSession(buildDirectConnectedSessionOptions(options, async ({ client, sessionId, record }) => {
+	return toSessionMutationResult(await withOwnedDirectSession(buildDirectConnectedSessionOptions({
+		...options,
+		replacingMode: true
+	}, async ({ client, sessionId, record }) => {
 		await withTimeout(client.setSessionMode(sessionId, options.modeId), options.timeoutMs);
 		setDesiredModeId(record, options.modeId);
 	})));
@@ -5806,8 +5974,14 @@ const sessionControlTestInternals = {
 };
 async function closeSession(sessionId) {
 	const record = await resolveSessionRecord(sessionId);
-	await tryCloseSessionOnRunningOwner({ sessionId: record.acpxRecordId }).catch(() => {});
-	await terminateQueueOwnerForSession(record.acpxRecordId);
+	let selectedOwner;
+	await tryCloseSessionOnRunningOwner({
+		sessionId: record.acpxRecordId,
+		onOwnerSelected: (owner) => {
+			selectedOwner = owner;
+		}
+	}).catch(() => {});
+	if (selectedOwner) await terminateQueueOwnerForSession(record.acpxRecordId, selectedOwner);
 	if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record.agentCommand)) await terminateProcess(record.pid);
 	const ownership = await acquireSessionTurn(record.acpxRecordId);
 	try {
@@ -5825,9 +5999,11 @@ async function closeSession(sessionId) {
 //#region src/session/execution/session-management.ts
 async function createSessionRecordWithClient(client, options) {
 	const cwd = absolutePath(options.cwd);
-	await withTimeout(client.start(), options.timeoutMs);
+	await withTimeout(client.start({ signal: options.signal }), options.timeoutMs);
+	assertControlAuthority({ signal: options.signal });
 	const createdState = options.resumeSessionId ? await resumeSessionRecordWithClient(client, options, cwd) : await createFreshSessionState(client, options, cwd);
 	const { sessionId, agentSessionId } = createdState;
+	assertControlAuthority({ signal: options.signal });
 	const lifecycle = client.getAgentLifecycleSnapshot();
 	const record = {
 		...createInitialSessionRecord({
@@ -5849,10 +6025,12 @@ async function createSessionRecordWithClient(client, options) {
 	applyConfigOptionsToRecord(record, createdState.sessionResult);
 	applyInitialModelSelection(record, createdState.sessionResult.models, options.sessionOptions?.model, createdState.modelApplication);
 	await writeSessionRecord(record);
+	assertControlAuthority({ signal: options.signal });
 	return record;
 }
 async function createFreshSessionState(client, options, cwd) {
-	const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
+	const createdSession = await withTimeout(client.createSession(cwd, { signal: options.signal }), options.timeoutMs);
+	assertControlAuthority({ signal: options.signal });
 	const modelApplication = await applyRequestedModelIfAdvertised({
 		client,
 		sessionId: createdSession.sessionId,
@@ -5860,7 +6038,8 @@ async function createFreshSessionState(client, options, cwd) {
 		models: createdSession.models,
 		agentCommand: options.agentCommand,
 		timeoutMs: options.timeoutMs,
-		onWarning: options.onModelWarning
+		onWarning: options.onModelWarning,
+		authority: { signal: options.signal }
 	});
 	return {
 		sessionId: createdSession.sessionId,
@@ -5874,8 +6053,9 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 	const resumeMethod = client.supportsResumeSession() ? "session/resume" : client.supportsLoadSession() ? "session/load" : void 0;
 	if (!resumeMethod) throw new Error(`Agent command "${options.agentCommand}" does not support session/resume or session/load; cannot resume session ${options.resumeSessionId}`);
 	try {
-		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd) : client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
+		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd, { signal: options.signal }) : client.loadSessionWithOptions(options.resumeSessionId, cwd, { authority: { signal: options.signal } }), options.timeoutMs);
 		const sessionModels = resumedSession.models;
+		assertControlAuthority({ signal: options.signal });
 		const modelApplication = await applyRequestedModelIfAdvertised({
 			client,
 			sessionId: options.resumeSessionId,
@@ -5883,7 +6063,8 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 			models: sessionModels,
 			agentCommand: options.agentCommand,
 			timeoutMs: options.timeoutMs,
-			onWarning: options.onModelWarning
+			onWarning: options.onModelWarning,
+			authority: { signal: options.signal }
 		});
 		return {
 			sessionId: options.resumeSessionId,
@@ -5896,7 +6077,7 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 	}
 }
 async function createSessionWithClient(options) {
-	options.signal?.throwIfAborted();
+	assertControlAuthority({ signal: options.signal });
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
 		agentArgv: options.agentArgv,
@@ -5912,28 +6093,25 @@ async function createSessionWithClient(options) {
 		verbose: options.verbose,
 		sessionOptions: options.sessionOptions
 	});
-	const onAbort = () => {
-		client.close().catch(() => {});
-	};
-	options.signal?.addEventListener("abort", onAbort, { once: true });
+	const closeOwnedClient = ownDirectClient(client, options.signal);
 	try {
 		const create = async () => {
-			options.signal?.throwIfAborted();
+			assertControlAuthority({ signal: options.signal });
 			const record = await createSessionRecordWithClient(client, options);
-			options.signal?.throwIfAborted();
+			assertControlAuthority({ signal: options.signal });
 			return record;
 		};
 		return {
 			record: options.handleProcessInterrupts === false ? await create() : await withInterrupt(create, async () => {
-				await client.close();
+				await closeOwnedClient();
 			}),
 			client
 		};
 	} catch (error) {
-		await client.close();
-		throw error;
+		await closeOwnedClient();
+		throw directExecutionError(error, options.signal);
 	} finally {
-		options.signal?.removeEventListener("abort", onAbort);
+		closeOwnedClient.release();
 	}
 }
 async function createSession(options) {
@@ -5999,7 +6177,7 @@ async function ensureSession(options) {
 	}
 }
 async function ensureSessionWithOwnership(options, cwd) {
-	options.signal?.throwIfAborted();
+	assertControlAuthority({ signal: options.signal });
 	const gitRoot = findGitRepositoryRoot(cwd);
 	const walkBoundary = options.walkBoundary ?? gitRoot ?? cwd;
 	const existing = await findSessionByDirectoryWalk({
@@ -6509,27 +6687,27 @@ const NODE_TEST_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
 	"--test-reporter",
 	"--test-reporter-destination"
 ]);
-const INSPECTOR_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
+const INSPECTOR_FLAGS = /* @__PURE__ */ new Set([
 	"--inspect",
 	"--inspect-brk",
+	"--inspect-wait"
+]);
+const INSPECTOR_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set([
 	"--inspect-port",
 	"--inspect-publish-uid",
 	"--debug-port"
 ]);
-const INSPECTOR_FLAG_PREFIXES = [
-	"--inspect=",
-	"--inspect-brk=",
-	"--inspect-port=",
-	"--inspect-publish-uid=",
-	"--debug-port="
-];
 function classifyExecArgv(value) {
-	if (value === void 0) return "drop";
-	if (NODE_TEST_FLAGS_WITH_VALUE.has(value) || INSPECTOR_FLAGS_WITH_VALUE.has(value)) return "drop-with-value";
-	return dropSingleExecArgv(value) ? "drop" : "keep";
+	if (NODE_TEST_FLAGS_WITH_VALUE.has(value)) return "drop-with-value";
+	if (NODE_TEST_FLAGS.has(value) || value.startsWith("--test-")) return "drop";
+	return classifyInspectorArgv(value);
 }
-function dropSingleExecArgv(value) {
-	return NODE_TEST_FLAGS.has(value) || value.startsWith("--test-") || INSPECTOR_FLAG_PREFIXES.some((prefix) => value.startsWith(prefix));
+function classifyInspectorArgv(value) {
+	const [name] = value.split("=", 1);
+	if (!name?.startsWith("--")) return "keep";
+	const flag = name.replaceAll("_", "-");
+	if (INSPECTOR_FLAGS_WITH_VALUE.has(flag)) return value.includes("=") ? "drop" : "drop-with-value";
+	return INSPECTOR_FLAGS.has(flag) ? "drop" : "keep";
 }
 function sanitizeQueueOwnerExecArgv(execArgv = process.execArgv) {
 	const sanitized = [];
@@ -6795,10 +6973,11 @@ var QueueTaskOutputFormatter = class {
 		this.send = task.send;
 	}
 	setContext(_context) {}
-	onAcpMessage(message) {
+	onAcpMessage(message, direction) {
 		this.send({
 			type: "event",
 			requestId: this.requestId,
+			...direction === void 0 ? {} : { direction },
 			message
 		});
 	}
@@ -6855,7 +7034,7 @@ var AcpErrorTracker = class {
 		this.outbound.length = 0;
 	}
 	observe(output, direction, message) {
-		output.onAcpMessage(message);
+		output.onAcpMessage(message, direction);
 		const acp = extractAcpError(message);
 		if (!acp) return;
 		if (direction === "inbound") {
@@ -6889,6 +7068,7 @@ async function applyPromptModelIfAdvertised(params) {
 		models: advertisedModelState(params.record.acpx),
 		agentCommand: params.record.agentCommand,
 		timeoutMs: params.timeoutMs,
+		authority: { signal: params.signal },
 		onWarning: params.suppressWarnings ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
 	});
 	if (result.applied) params.record.acpx = applyModelSelection(params.record.acpx, requestedModel, result.response);
@@ -7073,7 +7253,7 @@ async function waitForSessionTurn(options) {
 		"SIGTERM",
 		"SIGHUP"
 	];
-	for (const signal of signals) process.once(signal, onInterrupt);
+	if (options.handleProcessInterrupts !== false) for (const signal of signals) process.once(signal, onInterrupt);
 	const timeoutMs = options.timeoutMs;
 	const timeout = timeoutMs != null && timeoutMs > 0 ? setTimeout(() => waiting.abort(new TimeoutError(timeoutMs)), timeoutMs) : void 0;
 	const signal = options.waitSignal ? AbortSignal.any([waiting.signal, options.waitSignal]) : waiting.signal;
@@ -7084,18 +7264,22 @@ async function waitForSessionTurn(options) {
 			ownership: await acquireSessionTurn(acpxRecordId, signal)
 		};
 	} catch (error) {
-		signal.throwIfAborted();
-		throw error;
+		return throwTurnAcquisitionError(error, signal);
 	} finally {
 		clearTimeout(timeout);
 		for (const signal of signals) process.off(signal, onInterrupt);
 	}
 }
+function throwTurnAcquisitionError(error, signal) {
+	if (signal.aborted && error instanceof Error && error.name === "AbortError" && error.cause === signal.reason) throw signal.reason;
+	throw error;
+}
 async function runSessionPrompt(options) {
 	let turn;
 	try {
 		turn = await waitForSessionTurn(options);
 	} catch (error) {
+		if (options.ownedSignal) throw error;
 		if (options.waitSignal?.aborted && error === options.waitSignal.reason) {
 			const record = await resolveSessionRecord(options.sessionRecordId);
 			return {
@@ -7215,8 +7399,10 @@ async function runOwnedSessionPrompt(options) {
 	const record = await measurePerf("session.resolve_prompt_record", async () => {
 		return await resolveSessionRecord(options.sessionRecordId);
 	});
+	options.ownedSignal?.throwIfAborted();
 	const { conversation, promptMessageId } = preparePromptConversation(record, options);
 	await writeSessionRecord(record);
+	options.ownedSignal?.throwIfAborted();
 	output.setContext({ sessionId: record.acpxRecordId });
 	const eventWriter = await measurePerf("session.events.open", async () => {
 		return await SessionEventWriter.open(record);
@@ -7259,7 +7445,7 @@ async function runOwnedSessionPrompt(options) {
 			if (options.verbose) process.stderr.write("[acpx] live session checkpoint failed: " + formatErrorMessage(error) + "\n");
 		}
 	});
-	let closeClientOnExit = options.client == null;
+	let closeClientOnExit = options.client == null || options.ownedSignal !== void 0;
 	const client = options.client ?? new AcpClient({
 		agentCommand: record.agentCommand,
 		agentArgv: record.agentArgv,
@@ -7285,6 +7471,7 @@ async function runOwnedSessionPrompt(options) {
 		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
 		verbose: options.verbose
 	});
+	const closeOwnedClient = options.closeProvidedClient ?? ownDirectClient(client, options.ownedSignal);
 	client.setEventHandlers({
 		onAcpMessage: (direction, message) => {
 			pendingMessages.push(message);
@@ -7358,6 +7545,7 @@ async function runOwnedSessionPrompt(options) {
 					verbose: options.verbose,
 					suppressWarnings: options.suppressSdkConsoleErrors,
 					activeController,
+					authority: { signal: options.ownedSignal },
 					onClientAvailable: (controller) => {
 						options.onClientAvailable?.(controller);
 						notifiedClientAvailable = true;
@@ -7464,15 +7652,19 @@ async function runOwnedSessionPrompt(options) {
 		return response;
 	};
 	const runPrompt = async () => {
+		options.ownedSignal?.throwIfAborted();
 		const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
+		options.ownedSignal?.throwIfAborted();
 		await applyPromptModelIfAdvertised({
 			client,
 			sessionId: activeSessionId,
 			requestedModel: options.sessionOptions?.model,
 			record,
 			timeoutMs: options.timeoutMs,
-			suppressWarnings: options.suppressSdkConsoleErrors
+			suppressWarnings: options.suppressSdkConsoleErrors,
+			signal: options.ownedSignal
 		});
+		options.ownedSignal?.throwIfAborted();
 		output.setContext({ sessionId: record.acpxRecordId });
 		await liveCheckpoint.checkpoint();
 		const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
@@ -7490,20 +7682,23 @@ async function runOwnedSessionPrompt(options) {
 		record.lastUsedAt = isoNow$1();
 		applyConversation(record, conversation);
 		await flushPendingMessages(false).catch(() => {});
-		if (closeClientOnExit) await client.close();
+		if (closeClientOnExit) await closeOwnedClient();
 	};
 	const runObservedPrompt = async () => {
 		try {
-			return await runWithOptionalInterrupt({
+			const result = await runWithOptionalInterrupt({
 				handleProcessInterrupts: options.handleProcessInterrupts,
 				run: runPrompt,
 				handleInterrupt
 			});
+			options.ownedSignal?.throwIfAborted();
+			return result;
 		} catch (error) {
-			const matchedAcpError = acpErrors.match(error);
-			attachAcpErrorPayload(error, matchedAcpError);
-			markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
-			throw error;
+			const failure = directExecutionError(error, options.ownedSignal);
+			const matchedAcpError = acpErrors.match(failure);
+			attachAcpErrorPayload(failure, matchedAcpError);
+			markOutputAlreadyEmitted(failure, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+			throw failure;
 		}
 	};
 	const cleanupPrompt = async (attempt) => {
@@ -7516,7 +7711,7 @@ async function runOwnedSessionPrompt(options) {
 			async () => {
 				const journalFailed = attempt.status === "rejected" && attempt.error instanceof AcpxOperationalError && attempt.error.detailCode === "SESSION_JOURNAL_WRITE_FAILED";
 				if (unresolvedPrompt || closeClientOnExit || journalFailed) try {
-					await client.close();
+					await closeOwnedClient();
 				} catch (error) {
 					options.onClientCloseFailure?.();
 					throw error;
@@ -7554,7 +7749,8 @@ async function runOwnedSessionPrompt(options) {
 		cleanup: cleanupPrompt
 	});
 }
-async function runOnce(options) {
+async function runOnce(options, control) {
+	const authority = { signal: control?.signal };
 	const output = options.outputFormatter;
 	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
 	let promptTurnActive = false;
@@ -7594,10 +7790,12 @@ async function runOnce(options) {
 		},
 		sessionOptions: options.sessionOptions
 	});
+	const closeOwnedClient = ownDirectClient(client, control?.signal);
 	const runExecPromptAttempt = async (sessionId) => {
+		assertControlAuthority(authority);
 		acpErrors.reset();
 		return await measurePerf("runtime.exec.prompt", async () => {
-			return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
+			return await withTimeout(client.prompt(sessionId, options.prompt, void 0, void 0, void 0, { signal: control?.signal }), options.timeoutMs);
 		});
 	};
 	const runExecPromptWithRetries = async (sessionId) => {
@@ -7606,78 +7804,105 @@ async function runOnce(options) {
 		for (let attempt = 0;; attempt++) try {
 			return await runExecPromptAttempt(sessionId);
 		} catch (error) {
-			if (await preparePromptRetry(error, attempt, maxRetries, () => promptTurnHadSideEffects, options.suppressSdkConsoleErrors)) continue;
+			if (await preparePromptRetry(error, attempt, maxRetries, () => promptTurnHadSideEffects, options.suppressSdkConsoleErrors, control?.signal)) continue;
 			promptTurnActive = false;
 			throw error;
 		}
 	};
 	try {
-		return await withInterrupt(async () => {
-			await measurePerf("runtime.exec.start", async () => {
-				await withTimeout(client.start(), options.timeoutMs);
-			});
-			const createdSession = await measurePerf("runtime.exec.create_session", async () => {
-				return await withTimeout(client.createSession(absolutePath(options.cwd)), options.timeoutMs);
-			});
-			const sessionId = createdSession.sessionId;
-			if (createdSession.models) applyAdvertisedModelState(controlState, createdSession.models);
-			controlState = applyConfigOptionsToState(controlState, createdSession.configOptions ?? []);
-			const modelApplication = await applyRequestedModelIfAdvertised({
-				client,
-				sessionId,
-				requestedModel: options.sessionOptions?.model,
-				models: createdSession.models,
-				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs,
-				onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
-			});
-			if (modelApplication.response) controlState = applyConfigOptionsToState(controlState, modelApplication.response.configOptions);
-			for (const configOption of options.configOptions ?? []) {
-				const response = await withTimeout(client.setSessionConfigOption(sessionId, configOption.configId, configOption.value, advertisedModelState(controlState)), options.timeoutMs);
-				controlState = applyConfigOptionsToState(controlState, response.configOptions);
+		return await runWithOptionalInterrupt({
+			handleProcessInterrupts: control?.handleProcessInterrupts,
+			run: async () => {
+				assertControlAuthority(authority);
+				await measurePerf("runtime.exec.start", async () => {
+					await withTimeout(client.start(authority), options.timeoutMs);
+				});
+				assertControlAuthority(authority);
+				const createdSession = await measurePerf("runtime.exec.create_session", async () => {
+					return await withTimeout(client.createSession(absolutePath(options.cwd), authority), options.timeoutMs);
+				});
+				assertControlAuthority(authority);
+				const sessionId = createdSession.sessionId;
+				if (createdSession.models) applyAdvertisedModelState(controlState, createdSession.models);
+				controlState = applyConfigOptionsToState(controlState, createdSession.configOptions ?? []);
+				const modelApplication = await applyRequestedModelIfAdvertised({
+					client,
+					sessionId,
+					requestedModel: options.sessionOptions?.model,
+					models: createdSession.models,
+					agentCommand: options.agentCommand,
+					timeoutMs: options.timeoutMs,
+					authority,
+					onWarning: options.suppressSdkConsoleErrors ? void 0 : (message) => process.stderr.write(`[acpx] warning: ${message}\n`)
+				});
+				if (modelApplication.response) controlState = applyConfigOptionsToState(controlState, modelApplication.response.configOptions);
+				for (const configOption of options.configOptions ?? []) {
+					assertControlAuthority(authority);
+					const response = await withTimeout(client.setSessionConfigOption(sessionId, configOption.configId, configOption.value, advertisedModelState(controlState), authority), options.timeoutMs);
+					controlState = applyConfigOptionsToState(controlState, response.configOptions);
+				}
+				assertControlAuthority(authority);
+				output.setContext({ sessionId });
+				const response = await runExecPromptWithRetries(sessionId);
+				promptTurnActive = false;
+				return toPromptResult(response.stopReason, sessionId, client, response._meta);
+			},
+			handleInterrupt: async () => {
+				await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
+				await closeOwnedClient();
 			}
-			output.setContext({ sessionId });
-			const response = await runExecPromptWithRetries(sessionId);
-			promptTurnActive = false;
-			output.flush();
-			return toPromptResult(response.stopReason, sessionId, client, response._meta);
-		}, async () => {
-			await client.cancelActivePrompt(INTERRUPT_CANCEL_WAIT_MS);
-			await client.close();
 		});
 	} catch (error) {
-		const matchedAcpError = acpErrors.match(error);
-		attachAcpErrorPayload(error, matchedAcpError);
-		markOutputAlreadyEmitted(error, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
-		throw error;
+		const failure = directExecutionError(error, authority.signal);
+		const matchedAcpError = acpErrors.match(failure);
+		attachAcpErrorPayload(failure, matchedAcpError);
+		markOutputAlreadyEmitted(failure, matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted);
+		throw failure;
 	} finally {
-		await client.close();
+		try {
+			await closeOwnedClient();
+		} finally {
+			try {
+				options.onPermissionStats?.(client.getPermissionStats());
+			} catch {}
+			output.flush();
+		}
 	}
 }
-async function sendSessionDirect(options) {
-	return await runSessionPrompt({
-		sessionRecordId: options.sessionId,
-		prompt: options.prompt,
-		mcpServers: options.mcpServers,
-		permissionMode: options.permissionMode,
-		resumePolicy: options.resumePolicy,
-		nonInteractivePermissions: options.nonInteractivePermissions,
-		permissionPolicy: options.permissionPolicy,
-		authCredentials: options.authCredentials,
-		authPolicy: options.authPolicy,
-		fs: options.fs,
-		terminal: options.terminal,
-		outputFormatter: options.outputFormatter,
-		errorEmissionPolicy: options.errorEmissionPolicy,
-		onAcpMessage: options.onAcpMessage,
-		onSessionUpdate: options.onSessionUpdate,
-		onClientOperation: options.onClientOperation,
-		onPermissionEscalation: options.onPermissionEscalation,
-		timeoutMs: options.timeoutMs,
-		suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
-		verbose: options.verbose,
-		client: options.client
-	});
+async function sendSessionDirect(options, control) {
+	const closeProvidedClient = control && options.client ? ownDirectClient(options.client, control.signal) : void 0;
+	try {
+		control?.signal.throwIfAborted();
+		return await runSessionPrompt({
+			ownedSignal: control?.signal,
+			closeProvidedClient,
+			waitSignal: control?.signal,
+			handleProcessInterrupts: control?.handleProcessInterrupts,
+			sessionRecordId: options.sessionId,
+			prompt: options.prompt,
+			mcpServers: options.mcpServers,
+			permissionMode: options.permissionMode,
+			resumePolicy: options.resumePolicy,
+			nonInteractivePermissions: options.nonInteractivePermissions,
+			permissionPolicy: options.permissionPolicy,
+			authCredentials: options.authCredentials,
+			authPolicy: options.authPolicy,
+			fs: options.fs,
+			terminal: options.terminal,
+			outputFormatter: options.outputFormatter,
+			errorEmissionPolicy: options.errorEmissionPolicy,
+			onAcpMessage: options.onAcpMessage,
+			onSessionUpdate: options.onSessionUpdate,
+			onClientOperation: options.onClientOperation,
+			onPermissionEscalation: options.onPermissionEscalation,
+			timeoutMs: options.timeoutMs,
+			suppressSdkConsoleErrors: options.suppressSdkConsoleErrors,
+			verbose: options.verbose,
+			client: options.client
+		});
+	} finally {
+		await closeProvidedClient?.();
+	}
 }
 //#endregion
 //#region src/session/execution/queue-owner-runtime.ts
@@ -8079,6 +8304,6 @@ async function sendSession(options) {
 }
 const queueOwnerRuntimeTestInternals = { queueOwnerExitIsFatal };
 //#endregion
-export { getAcpxVersion as $, applyInitialModelSelection as A, cloneSessionAcpxState as B, setSessionModeOnOwner as C, connectAndLoadSession as D, withConnectedSession as E, sessionOptionsFromRecord as F, recordSessionUpdate as G, createSessionConversation as H, applyConversation as I, AcpClient as J, trimConversationForRuntime as K, applyLifecycleSnapshotToRecord as L, applyRequestedModelIfAdvertised as M, setDesiredModeId as N, applyConfigOptionSelection as O, persistSessionOptions as P, isRequestedModelUnsupportedError as Q, createInitialSessionRecord as R, setSessionMode as S, setSessionModelOnOwner as T, recordClientOperation as U, cloneSessionConversation as V, recordPromptSubmission as W, REQUESTED_MODEL_UNSUPPORTED_REASONS as X, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as Y, RequestedModelUnsupportedError as Z, cancelSessionPrompt as _, runQueuedTask as a, InterruptedError as at, setSessionConfigOption as b, LiveSessionCheckpoint as c, withInterrupt as ct, flushPerfMetricsCapture as d, normalizeOutputError as dt, permissionModeSatisfies as et, installPerfMetricsCapture as f, listAgentSessions as g, ensureSession as h, runOnce as i, isLegacyZedCodexAcpInvocation as it, applyModelSelection as j, applyConfigOptionsToRecord as k, runPromptTurn as l, withTimeout as lt, createSessionWithClient as m, runSessionQueueOwner as n, normalizeQueueOwnerTtlMs as nt, sendSessionDirect as o, TimeoutError as ot, createSession as p, advertisedModelState as q, sendSession as r, listSessionEvents as rt, DISCARD_OUTPUT_FORMATTER as s, assertControlAuthority as st, queueOwnerRuntimeTestInternals as t, DEFAULT_QUEUE_OWNER_TTL_MS as tt, buildQueueOwnerArgOverride as u, exitCodeForOutputErrorCode as ut, closeSession as v, setSessionModel as w, setSessionConfigOptionOnOwner as x, sessionControlTestInternals as y, reconcileAgentSessionId as z };
+export { isRequestedModelUnsupportedError as $, applyInitialModelSelection as A, reconcileAgentSessionId as B, setSessionModeOnOwner as C, connectAndLoadSession as D, withConnectedSession as E, persistSessionOptions as F, recordPromptSubmission as G, cloneSessionConversation as H, sessionOptionsFromRecord as I, advertisedModelState as J, recordSessionUpdate as K, applyConversation as L, applyRequestedModelIfAdvertised as M, setDesiredModeId as N, applyConfigOptionSelection as O, normalizeSessionOptionShape as P, RequestedModelUnsupportedError as Q, applyLifecycleSnapshotToRecord as R, setSessionMode as S, setSessionModelOnOwner as T, createSessionConversation as U, cloneSessionAcpxState as V, recordClientOperation as W, REQUESTED_MODEL_UNSUPPORTED_ERROR_CODE as X, AcpClient as Y, REQUESTED_MODEL_UNSUPPORTED_REASONS as Z, cancelSessionPrompt as _, runQueuedTask as a, isLegacyZedCodexAcpInvocation as at, setSessionConfigOption as b, LiveSessionCheckpoint as c, assertControlAuthority as ct, flushPerfMetricsCapture as d, exitCodeForOutputErrorCode as dt, getAcpxVersion as et, installPerfMetricsCapture as f, normalizeOutputError as ft, listAgentSessions as g, ensureSession as h, runOnce as i, listSessionEvents as it, applyModelSelection as j, applyConfigOptionsToRecord as k, runPromptTurn as l, withInterrupt as lt, createSessionWithClient as m, runSessionQueueOwner as n, DEFAULT_QUEUE_OWNER_TTL_MS as nt, sendSessionDirect as o, InterruptedError as ot, createSession as p, trimConversationForRuntime as q, sendSession as r, normalizeQueueOwnerTtlMs as rt, DISCARD_OUTPUT_FORMATTER as s, TimeoutError as st, queueOwnerRuntimeTestInternals as t, permissionModeSatisfies as tt, buildQueueOwnerArgOverride as u, withTimeout as ut, closeSession as v, setSessionModel as w, setSessionConfigOptionOnOwner as x, sessionControlTestInternals as y, createInitialSessionRecord as z };
 
-//# sourceMappingURL=queue-owner-runtime-Cr0dWJuL.js.map
+//# sourceMappingURL=queue-owner-runtime-C4OOosbo.js.map