acpx 0.18.0 → 0.19.0

package/dist/{queue-owner-runtime-Cr0dWJuL.js → queue-owner-runtime-CLwjMYNL.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 readProcessTable, xt as formatUnknownErrorMessage, y as createLockOwner, yt as isProcessAlive, z as resolveSessionRecord, zt as GeminiAcpStartupTimeoutError } from "./ipc-fMgj5vrO.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-Ct2yWPW7.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))}`;
@@ -1556,15 +1558,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 +1581,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) {
@@ -1667,65 +1673,88 @@ function promptRequestOwner(message) {
 }
 //#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;
+		for (const identity of table.values()) {
+			const parent = table.get(identity.parentPid);
+			if (process.platform === "win32" && (!parent || parent.birth > identity.birth)) continue;
+			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. */
+/** Best-effort cleanup for descendants witnessed during this child launch. */
 var ProcessDescendants = class {
 	child;
 	identities = /* @__PURE__ */ new Map();
+	rootBirth;
 	pending;
 	retired = false;
-	constructor(child) {
+	ownProcessGroup;
+	captureGroupAfterExit;
+	groupExitedAt;
+	onRootExit = () => {
+		this.groupExitedAt = Date.now();
+	};
+	constructor(child, options = {}) {
 		this.child = child;
+		this.ownProcessGroup = process.platform !== "win32" && Boolean(options.ownProcessGroup);
+		this.captureGroupAfterExit = this.ownProcessGroup && isChildProcessRunning(child);
+		if (this.ownProcessGroup) child.once("exit", this.onRootExit);
 	}
 	capture(timeoutMs = PROCESS_HELPER_TIMEOUT_MS) {
-		if (this.retired || process.platform === "win32") return Promise.resolve(true);
+		if (this.retired) return Promise.resolve(true);
 		this.pending ??= this.readSnapshot(timeoutMs).finally(() => {
 			this.pending = void 0;
 		});
 		return this.pending;
 	}
 	async readSnapshot(timeoutMs) {
+		const deadline = performance.now() + timeoutMs;
+		const rootWasRunning = isChildProcessRunning(this.child);
+		const captureRootGroup = rootWasRunning || this.captureGroupAfterExit;
+		if (!rootWasRunning) this.captureGroupAfterExit = false;
 		try {
-			const output = await runTimedExecFile("ps", ["-eo", "pid=,ppid=,stat=,lstart="], { timeoutMs });
-			if (!this.retired) this.refresh(parseProcessTable(output));
+			const table = await readProcessTable(timeoutMs);
+			if (!this.retired) {
+				table.delete(1);
+				table.delete(process.pid);
+				this.refresh(table, captureRootGroup);
+				if (this.captureGroupAfterExit && !isChildProcessRunning(this.child)) return await this.readSnapshot(Math.max(1, deadline - performance.now()));
+			}
 			return true;
 		} catch {
+			if (!isChildProcessRunning(this.child)) this.captureGroupAfterExit = false;
 			return false;
 		}
 	}
-	refresh(table) {
+	refresh(table, rootWasRunning) {
 		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);
+		this.includeRoot(table, owned);
+		if (this.ownProcessGroup) this.includeProcessGroup(table, owned, rootWasRunning);
 		includeDescendants(table, owned);
-		owned.delete(root ?? 0);
+		owned.delete(this.child.pid ?? 0);
 		this.identities = new Map([...table].filter(([pid]) => owned.has(pid)));
 	}
+	includeRoot(table, owned) {
+		const root = this.child.pid;
+		const rootIdentity = root && table.get(root);
+		if (rootIdentity && isChildProcessRunning(this.child)) {
+			this.rootBirth ??= rootIdentity.birth;
+			if (rootIdentity.birth === this.rootBirth) owned.add(rootIdentity.pid);
+		}
+	}
+	includeProcessGroup(table, owned, rootWasRunning) {
+		const root = this.child.pid;
+		if (root && (rootWasRunning || [...owned].some((pid) => table.get(pid)?.groupPid === root))) {
+			for (const identity of table.values()) if (identity.groupPid === root && (this.groupExitedAt === void 0 || Date.parse(identity.birth) <= this.groupExitedAt)) owned.add(identity.pid);
+		}
+	}
 	async signal(signal, timeoutMs) {
 		if (!await this.capture(timeoutMs) || this.retired) return;
 		for (const pid of this.identities.keys()) try {
@@ -1734,6 +1763,9 @@ var ProcessDescendants = class {
 			this.identities.delete(pid);
 		}
 	}
+	hasTrackedProcesses() {
+		return this.identities.size > 0;
+	}
 	async waitForExit(timeoutMs) {
 		const deadline = Date.now() + timeoutMs;
 		do {
@@ -1745,6 +1777,7 @@ var ProcessDescendants = class {
 	}
 	retire() {
 		this.retired = true;
+		this.child.off("exit", this.onRootExit);
 		this.identities.clear();
 	}
 };
@@ -1812,12 +1845,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 +1895,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 +1917,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 +1927,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 +1941,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 +1951,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 +1964,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 +2078,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 +2103,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 +2127,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 +2142,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 +2162,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 +2170,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 +2197,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 +2225,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 +2258,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 +2289,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 {
@@ -2441,6 +2444,7 @@ var AcpClient = class {
 	cancellingSessionIds = /* @__PURE__ */ new Set();
 	permissionAbortControllers = /* @__PURE__ */ new Map();
 	closing = false;
+	closeTask;
 	closeEpoch = 0;
 	agentStartedAt;
 	lastAgentExit;
@@ -2537,7 +2541,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 +2564,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();
+		assertControlAuthority(authority);
 		this.logAgentLaunch(launch);
 		await this.ensureLaunchSupport(launch);
-		const { child, process: startedProcess } = await this.spawnAgentProcess(launch);
+		assertControlAuthority(authority);
+		const { child, process: startedProcess } = await this.spawnAgentProcess(launch, authority);
 		if (this.closeEpoch === epoch) {
 			this.agent = child;
 			this.closing = false;
@@ -2591,7 +2597,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 +2612,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,6 +2624,14 @@ var AcpClient = class {
 			launch,
 			capabilities
 		});
+		if (connection.signal.aborted) onConnectionClose();
+	}
+	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() {
 		const configuredCommand = resolveAgentCommandParts(this.options.agentCommand, this.options.agentArgv);
@@ -2657,7 +2672,7 @@ var AcpClient = class {
 			this.log(`resolved system Claude Code executable: ${claudeExe}`);
 		}
 	}
-	async spawnAgentProcess(plan) {
+	async spawnAgentProcess(plan, authority) {
 		const spawnCommand = buildAgentSpawnCommand(plan.spawnCommand, plan.args, process.platform, plan.spawnOptions.env);
 		const launch = Object.freeze({
 			launchId: randomUUID(),
@@ -2667,6 +2682,7 @@ var AcpClient = class {
 			cwd: this.options.cwd
 		});
 		await this.options.processLifecycle?.onBeforeSpawn?.(launch);
+		assertControlAuthority(authority);
 		let spawnedChild;
 		try {
 			spawnedChild = spawn(spawnCommand.command, spawnCommand.args, {
@@ -2788,7 +2804,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 +2816,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 +2848,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 +2856,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 +2866,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);
@@ -3080,20 +3099,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 +3132,31 @@ var AcpClient = class {
 		this.connection = void 0;
 		this.agent = void 0;
 	}
-	async stopIfClosedDuringLaunch(epoch, child, startupFailure) {
+	async retireNativeResources() {
+		const agent = this.agent;
+		const failures = [];
+		try {
+			await this.terminalManager.shutdown();
+		} catch (error) {
+			failures.push(error);
+		}
+		try {
+			if (agent) await this.terminateAgentProcess(agent);
+		} catch (error) {
+			failures.push(error);
+		}
+		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() {
@@ -3475,7 +3518,7 @@ var AcpClient = class {
 	attachAgentLifecycleObservers(child, startedProcess, exitNotificationBarrier) {
 		const onExit = (exitCode, signal) => {
 			const exitedAt = isoNow$2();
-			this.recordAgentExit(child, "process_exit", exitCode, signal);
+			this.handleAgentDisconnect(child, "process_exit", exitCode, signal);
 			this.terminateAgentProcess(child);
 			exitNotificationBarrier.then(() => {
 				this.notifyProcessExit(startedProcess, exitCode, signal, exitedAt);
@@ -3487,10 +3530,17 @@ var AcpClient = class {
 			onExit(child.exitCode, child.signalCode);
 		}
 		child.once("close", (exitCode, signal) => {
-			this.recordAgentExit(child, "process_close", exitCode, signal);
+			this.handleAgentDisconnect(child, "process_close", exitCode, signal);
 		});
 		child.stdout.once("close", () => {
-			this.recordAgentExit(child, "pipe_close", child.exitCode ?? null, child.signalCode ?? null);
+			this.handleAgentDisconnect(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 +3904,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 +3913,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 +3969,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 +3977,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 +4023,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
 	});
@@ -4397,10 +4449,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 +4459,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 +4500,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 +4525,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 +4545,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 +4556,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 +4570,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 +4577,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 +4592,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 +4610,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 +4651,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 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, signal) {
+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 +4766,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 +4836,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 +5009,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 +5159,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 +5251,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 +5333,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 +5357,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 +5392,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 +5444,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 +5458,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 +5467,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 +5494,8 @@ async function replaySessionPreferences(params) {
 	reconcileAgentSessionId(params.record, params.pendingAgentSessionId);
 	return {
 		modelReplay,
-		configReplay
+		configReplay,
+		modeMetadata
 	};
 }
 function settleFailedReplay(params, replay, error) {
@@ -5381,11 +5527,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 +5547,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 +5564,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 +5636,7 @@ async function withConnectedSession(options) {
 				client,
 				record,
 				resumePolicy: options.resumePolicy,
+				replacingMode: options.replacingMode,
 				replacingConfigOption: options.replacingConfigOption,
 				authority: options.authority,
 				timeoutMs: options.timeoutMs,
@@ -5542,6 +5697,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 +5748,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 +5965,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 +5990,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 +6016,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 +6029,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 +6044,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 +6054,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 +6068,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 +6084,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 +6168,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 +6678,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 = [];
@@ -6889,6 +7058,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 +7243,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 +7254,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 +7389,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 +7435,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 +7461,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 +7535,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 +7642,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 +7672,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 +7701,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 +7739,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 +7780,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 +7794,102 @@ 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 {
+			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
@@ -8081,4 +8293,4 @@ 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 };
 
-//# sourceMappingURL=queue-owner-runtime-Cr0dWJuL.js.map
+//# sourceMappingURL=queue-owner-runtime-CLwjMYNL.js.map