acpx 0.19.0 → 0.19.2

package/dist/{queue-owner-runtime-CLwjMYNL.js → queue-owner-runtime-W0lly6ap.js}

@@ -1,5 +1,5 @@
-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 { $ as resetPerfMetrics, Bt as PermissionDeniedError, Ct as extractAcpError, E as textPrompt, F as normalizeName, Ft as AgentStartupError, G as SESSION_JOURNAL_SCHEMA, Gt as SessionModelReplayError, Ht as QueueConnectionError, It as AuthPolicyError, Jt as UnsupportedPromptContentError, K as SessionJournalReader, Lt as ClaudeAcpSessionCreateTimeoutError, M as isoNow$1, Mt as AcpxOperationalError, Nt as AgentDisconnectedError, O as absolutePath, Pt as AgentSpawnError, Q as measurePerf, R as resolveSessionRecord, Rt as CopilotAcpUnsupportedError, S as getUnsupportedPromptContentMessage, St as normalizeOutputError, T as promptToDisplayText, U as extractAgentSessionId, Ut as SessionConfigOptionReplayError, Vt as PermissionPromptUnavailableError, W as normalizeAgentSessionId, Wt as SessionModeReplayError, X as getPerfMetricsSnapshot, Y as formatPerfMetric, Z as incrementPerfCounter, _ as createLockOwner, _t as isProcessAlive, a as trySetModelOnRunningOwner, at as isSessionUpdateNotification, bt as isAcpQueryClosedBeforeResponseError, d as releaseQueueOwnerLease, dt as sessionBaseDir, et as setPerfGauge, f as terminateProcess, ft as sessionEventActivePath, g as QueueLeaseGuardSettlementError, h as waitMs$1, i as trySetModeOnRunningOwner, it as isAcpMessageObject, j as findSessionByDirectoryWalk, k as findGitRepositoryRoot, m as tryAcquireQueueOwnerLease, mt as sessionEventSegmentPath, n as tryCloseSessionOnRunningOwner, o as trySubmitToRunningOwner, p as terminateQueueOwnerForSession, pt as sessionEventLockPath, qt as SessionResumeRequiredError, r as trySetConfigOptionOnRunningOwner, rt as isAcpJsonRpcMessage, s as SessionQueueOwner, t as tryCancelOnRunningOwner, tt as startPerfTimer, u as refreshQueueOwnerLease, ut as defaultSessionEventLog, v as lockOwnerPid, wt as isAcpResourceNotFoundError, xt as isRetryablePromptError, y as ProcessDescendants, yt as formatErrorMessage, z as writeSessionRecord, zt as GeminiAcpStartupTimeoutError } from "./ipc-D0ZMQ0q9.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";
@@ -16,137 +16,6 @@ import { root } from "@openclaw/fs-safe/root";
 import readline from "node:readline/promises";
 import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
 import { acquireFileLock } from "@openclaw/fs-safe/file-lock";
-import net from "node:net";
-//#region src/acp/error-normalization.ts
-const AUTH_REQUIRED_ACP_CODES = /* @__PURE__ */ new Set([-32e3]);
-const QUERY_CLOSED_BEFORE_RESPONSE_DETAIL = "query closed before response received";
-function asRecord$3(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	return value;
-}
-function isAuthRequiredMessage(value) {
-	if (!value) return false;
-	const normalized = value.toLowerCase();
-	return [
-		"auth required",
-		"authentication required",
-		"authorization required",
-		"credential required",
-		"credentials required",
-		"token required",
-		"login required"
-	].some((needle) => normalized.includes(needle));
-}
-function isAcpAuthRequiredPayload(acp) {
-	if (!acp) return false;
-	if (!AUTH_REQUIRED_ACP_CODES.has(acp.code)) return false;
-	if (isAuthRequiredMessage(acp.message)) return true;
-	const data = asRecord$3(acp.data);
-	if (!data) return false;
-	return hasAuthRequiredData(data);
-}
-function hasAuthRequiredData(data) {
-	return data.authRequired === true || hasNonEmptyString(data.methodId) || hasNonEmptyArray(data.methods);
-}
-function hasNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function hasNonEmptyArray(value) {
-	return Array.isArray(value) && value.length > 0;
-}
-function isOutputErrorCode(value) {
-	return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
-}
-function isOutputErrorOrigin(value) {
-	return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
-}
-function readOutputErrorMeta(error) {
-	const record = asRecord$3(error);
-	if (!record) return {};
-	return {
-		outputCode: isOutputErrorCode(record.outputCode) ? record.outputCode : void 0,
-		detailCode: typeof record.detailCode === "string" && record.detailCode.trim().length > 0 ? record.detailCode : void 0,
-		origin: isOutputErrorOrigin(record.origin) ? record.origin : void 0,
-		retryable: typeof record.retryable === "boolean" ? record.retryable : void 0,
-		acp: extractAcpError(record.acp)
-	};
-}
-function isTimeoutLike(error) {
-	return error instanceof Error && error.name === "TimeoutError";
-}
-function isNoSessionLike(error) {
-	return error instanceof Error && error.name === "NoSessionError";
-}
-function isUsageLike(error) {
-	if (!(error instanceof Error)) return false;
-	return error.name === "CommanderError" || error.name === "InvalidArgumentError" || asRecord$3(error)?.code === "commander.invalidArgument";
-}
-function formatErrorMessage(error) {
-	return formatUnknownErrorMessage(error);
-}
-function isAcpQueryClosedBeforeResponseError(error) {
-	const acp = extractAcpError(error);
-	if (!acp || acp.code !== -32603) return false;
-	const details = asRecord$3(acp.data)?.details;
-	if (typeof details !== "string") return false;
-	return details.toLowerCase().includes(QUERY_CLOSED_BEFORE_RESPONSE_DETAIL);
-}
-function mapErrorCode(error) {
-	if (error instanceof PermissionPromptUnavailableError) return "PERMISSION_PROMPT_UNAVAILABLE";
-	if (error instanceof PermissionDeniedError) return "PERMISSION_DENIED";
-	if (isTimeoutLike(error)) return "TIMEOUT";
-	if (isNoSessionLike(error) || isAcpResourceNotFoundError(error)) return "NO_SESSION";
-	if (isUsageLike(error)) return "USAGE";
-}
-function normalizeOutputError(error, options = {}) {
-	const meta = readOutputErrorMeta(error);
-	const code = resolveOutputErrorCode(error, options, meta);
-	const acp = options.acp ?? meta.acp ?? extractAcpError(error);
-	return {
-		code,
-		message: formatErrorMessage(error),
-		detailCode: resolveDetailCode(error, acp, options, meta),
-		origin: meta.origin ?? options.origin,
-		retryable: meta.retryable ?? options.retryable,
-		acp
-	};
-}
-function resolveOutputErrorCode(error, options, meta) {
-	const code = meta.outputCode ?? mapErrorCode(error) ?? options.defaultCode ?? "RUNTIME";
-	if (code === "RUNTIME" && isAcpResourceNotFoundError(error)) return "NO_SESSION";
-	return code;
-}
-function resolveDetailCode(error, acp, options, meta) {
-	return meta.detailCode ?? options.detailCode ?? (error instanceof AuthPolicyError || isAcpAuthRequiredPayload(acp) ? "AUTH_REQUIRED" : void 0);
-}
-/**
-* Returns true when an error from `client.prompt()` looks transient and
-* can reasonably be retried (e.g. model-API 400/500, network hiccups that
-* surface as ACP internal errors).
-*
-* Errors that are definitively non-recoverable (auth, missing session,
-* invalid params, timeout, permission) return false.
-*/
-function isRetryablePromptError(error) {
-	if (isNonRetryablePromptError(error)) return false;
-	const acp = extractAcpError(error);
-	if (!acp) return false;
-	return acp.code === -32603 || acp.code === -32700;
-}
-function isNonRetryablePromptError(error) {
-	return error instanceof PermissionDeniedError || error instanceof PermissionPromptUnavailableError || isTimeoutLike(error) || isNoSessionLike(error) || isUsageLike(error);
-}
-function exitCodeForOutputErrorCode(code) {
-	switch (code) {
-		case "USAGE": return EXIT_CODES.USAGE;
-		case "TIMEOUT": return EXIT_CODES.TIMEOUT;
-		case "NO_SESSION": return EXIT_CODES.NO_SESSION;
-		case "PERMISSION_DENIED":
-		case "PERMISSION_PROMPT_UNAVAILABLE": return EXIT_CODES.PERMISSION_DENIED;
-		default: return EXIT_CODES.ERROR;
-	}
-}
-//#endregion
 //#region src/async-control.ts
 var TimeoutError = class extends Error {
 	constructor(timeoutMs) {
@@ -1080,63 +949,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(" ");
 }
@@ -1147,16 +975,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 = {};
@@ -1377,6 +1206,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"];
@@ -1672,116 +1568,6 @@ function promptRequestOwner(message) {
 	} : void 0;
 }
 //#endregion
-//#region src/acp/process-descendants.ts
-function includeDescendants(table, owned) {
-	let expanded;
-	do {
-		expanded = false;
-		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 cleanup for descendants witnessed during this child launch. */
-var ProcessDescendants = class {
-	child;
-	identities = /* @__PURE__ */ new Map();
-	rootBirth;
-	pending;
-	retired = false;
-	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) 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 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, rootWasRunning) {
-		const owned = /* @__PURE__ */ new Set();
-		for (const [pid, identity] of this.identities) if (table.get(pid)?.birth === identity.birth) owned.add(pid);
-		this.includeRoot(table, owned);
-		if (this.ownProcessGroup) this.includeProcessGroup(table, owned, rootWasRunning);
-		includeDescendants(table, owned);
-		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 {
-			process.kill(pid, signal);
-		} catch {
-			this.identities.delete(pid);
-		}
-	}
-	hasTrackedProcesses() {
-		return this.identities.size > 0;
-	}
-	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.child.off("exit", this.onRootExit);
-		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) {
@@ -2403,26 +2189,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;
@@ -2569,11 +2342,11 @@ var AcpClient = class {
 		if (this.hasLiveConnection()) return;
 		const epoch = await this.waitForPreviousClose();
 		const maxMessageBytes = readMaxAcpMessageBytes();
-		const launch = await this.resolveAgentLaunchPlan();
-		assertControlAuthority(authority);
+		const launch = await this.resolveAgentLaunchPlan(epoch, authority);
+		this.assertCommandProbeActive(epoch, authority);
 		this.logAgentLaunch(launch);
 		await this.ensureLaunchSupport(launch);
-		assertControlAuthority(authority);
+		this.assertCommandProbeActive(epoch, authority);
 		const { child, process: startedProcess } = await this.spawnAgentProcess(launch, authority);
 		if (this.closeEpoch === epoch) {
 			this.agent = child;
@@ -2633,12 +2406,29 @@ var AcpClient = class {
 		if (this.closeEpoch !== epoch) throw new Error("ACP client was closed while the agent was starting");
 		return epoch;
 	}
-	async resolveAgentLaunchPlan() {
+	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,
@@ -2648,7 +2438,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) {
@@ -2664,7 +2455,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) {
@@ -2672,22 +2463,36 @@ var AcpClient = class {
 			this.log(`resolved system Claude Code executable: ${claudeExe}`);
 		}
 	}
-	async spawnAgentProcess(plan, authority) {
-		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) {
@@ -2706,21 +2511,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;
@@ -2786,7 +2656,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
 		});
@@ -2896,7 +2766,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);
@@ -2914,7 +2783,6 @@ var AcpClient = class {
 			this.throwPromptPermissionFailureIfPresent(sessionId);
 			throw error;
 		} finally {
-			restoreConsoleError?.();
 			this.clearActivePrompt(activePrompt);
 		}
 	}
@@ -3133,18 +3001,15 @@ var AcpClient = class {
 		this.agent = void 0;
 	}
 	async retireNativeResources() {
-		const agent = this.agent;
+		const owned = [...this.commandProbes, ...this.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);
-		}
+		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 {
@@ -3170,6 +3035,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));
@@ -3179,12 +3049,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);
@@ -3195,18 +3065,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;
 	}
@@ -3516,19 +3386,10 @@ var AcpClient = class {
 		return cancelledPermissionResponse();
 	}
 	attachAgentLifecycleObservers(child, startedProcess, exitNotificationBarrier) {
-		const onExit = (exitCode, signal) => {
-			const exitedAt = isoNow$2();
+		this.attachProcessExitObserver(child, startedProcess, exitNotificationBarrier, (exitCode, signal) => {
 			this.handleAgentDisconnect(child, "process_exit", exitCode, signal);
 			this.terminateAgentProcess(child);
-			exitNotificationBarrier.then(() => {
-				this.notifyProcessExit(startedProcess, 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.handleAgentDisconnect(child, "process_close", exitCode, signal);
 		});
@@ -3536,6 +3397,18 @@ var AcpClient = class {
 			this.handleAgentDisconnect(child, "pipe_close", child.exitCode ?? null, child.signalCode ?? null);
 		});
 	}
+	attachProcessExitObserver(child, started, barrier, onProcessExit) {
+		const onExit = (exitCode, signal) => {
+			const exitedAt = isoNow$2();
+			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);
+		}
+	}
 	handleAgentDisconnect(child, reason, exitCode, signal) {
 		this.recordAgentExit(child, reason, exitCode, signal);
 		if (this.agent !== child || this.closing || !this.connection) return;
@@ -4353,6 +4226,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 {
@@ -4804,406 +4682,6 @@ 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 = {}) {
-	return {
-		type: "error",
-		requestId,
-		ownerGeneration: void 0,
-		code: "RUNTIME",
-		detailCode,
-		origin: "queue",
-		retryable: options.retryable,
-		message
-	};
-}
-function makeQueueOwnerErrorFromUnknown(requestId, error, detailCode, options = {}) {
-	const normalized = normalizeOutputError(error, {
-		defaultCode: "RUNTIME",
-		origin: "queue",
-		detailCode,
-		retryable: options.retryable
-	});
-	return {
-		type: "error",
-		requestId,
-		code: normalized.code,
-		detailCode: normalized.detailCode,
-		origin: normalized.origin,
-		message: normalized.message,
-		retryable: normalized.retryable,
-		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;
-	if (!socket.write(`${JSON.stringify(message)}\n`) && !socket.timeout) armSocketDrainTimeout(socket);
-}
-var SessionQueueOwner = class SessionQueueOwner {
-	server;
-	controlHandlers;
-	ownerGeneration;
-	maxQueueDepth;
-	maxRequestBytes;
-	onQueueDepthChanged;
-	pending = [];
-	activeTask;
-	waiters = [];
-	sockets = /* @__PURE__ */ new Set();
-	taskSockets = /* @__PURE__ */ new Set();
-	drainingSockets = /* @__PURE__ */ new Set();
-	closed = false;
-	constructor(server, controlHandlers, lease, options) {
-		this.server = server;
-		this.controlHandlers = controlHandlers;
-		this.ownerGeneration = lease.ownerGeneration;
-		this.maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth));
-		this.maxRequestBytes = queueRequestByteLimit(options.maxRequestBytes?.toString());
-		this.onQueueDepthChanged = options.onQueueDepthChanged;
-	}
-	static async start(lease, controlHandlers, options = { maxQueueDepth: 16 }) {
-		const ownerRef = { current: void 0 };
-		const server = net.createServer((socket) => {
-			ownerRef.current?.handleConnection(socket);
-		});
-		ownerRef.current = new SessionQueueOwner(server, controlHandlers, lease, options);
-		await new Promise((resolve, reject) => {
-			const onListening = () => {
-				server.off("error", onError);
-				resolve();
-			};
-			const onError = (error) => {
-				server.off("listening", onListening);
-				reject(error);
-			};
-			server.once("listening", onListening);
-			server.once("error", onError);
-			server.listen(lease.socketPath);
-		});
-		return ownerRef.current;
-	}
-	beginShutdown() {
-		if (this.closed) return;
-		this.closed = true;
-		for (const waiter of this.waiters.splice(0)) waiter(void 0);
-		for (const task of this.pending.splice(0)) {
-			if (task.waitForCompletion) task.send(makeQueueOwnerError(task.requestId, "Queue owner shutting down before prompt execution", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
-			task.close();
-		}
-		for (const socket of this.sockets) if (!this.taskSockets.has(socket) && !this.drainingSockets.has(socket)) socket.destroy();
-		this.emitQueueDepth();
-	}
-	async close() {
-		this.beginShutdown();
-		await new Promise((resolve) => {
-			const forceCloseTimer = setTimeout(() => {
-				for (const socket of this.sockets) socket.destroy();
-			}, QUEUE_SOCKET_DRAIN_TIMEOUT_MS);
-			forceCloseTimer.unref();
-			this.server.close(() => {
-				clearTimeout(forceCloseTimer);
-				resolve();
-			});
-		});
-	}
-	async nextTask(timeoutMs) {
-		if (this.pending.length > 0) {
-			const task = this.pending.shift();
-			this.emitQueueDepth();
-			if (task) {
-				this.activeTask = task;
-				recordPerfDuration("queue.owner.wait_ms", Date.now() - task.enqueuedAt);
-			}
-			return task;
-		}
-		if (this.closed) return;
-		return await new Promise((resolve) => {
-			const timer = timeoutMs != null && setTimeout(() => {
-				const index = this.waiters.indexOf(waiter);
-				if (index >= 0) this.waiters.splice(index, 1);
-				resolve(void 0);
-			}, Math.max(0, timeoutMs));
-			const waiter = (task) => {
-				if (timer) clearTimeout(timer);
-				resolve(task);
-			};
-			this.waiters.push(waiter);
-		});
-	}
-	queueDepth() {
-		return this.pending.length;
-	}
-	completeTask(task) {
-		if (this.activeTask === task) this.activeTask = void 0;
-	}
-	async cancelPrompt(targetRequestId) {
-		if (targetRequestId === void 0) return await this.controlHandlers.cancelPrompt();
-		const index = this.pending.findIndex((task) => task.requestId === targetRequestId);
-		if (index >= 0) {
-			const [task] = this.pending.splice(index, 1);
-			task.send(makeQueueOwnerError(task.requestId, "Prompt cancelled before execution", "QUEUE_REQUEST_CANCELLED", { retryable: false }));
-			task.close();
-			this.emitQueueDepth();
-			return true;
-		}
-		return this.activeTask?.requestId === targetRequestId ? await this.controlHandlers.cancelPrompt() : false;
-	}
-	emitQueueDepth() {
-		this.onQueueDepthChanged?.(this.pending.length);
-	}
-	enqueue(task) {
-		if (this.closed) {
-			task.send(makeQueueOwnerError(task.requestId, "Queue owner is shutting down", "QUEUE_OWNER_SHUTTING_DOWN", { retryable: true }));
-			task.close();
-			return false;
-		}
-		if (this.activeTask?.requestId === task.requestId || this.pending.some((queued) => queued.requestId === task.requestId)) {
-			task.send(makeQueueOwnerError(task.requestId, "Request is already queued or active", "QUEUE_REQUEST_DUPLICATE", { retryable: false }));
-			task.close();
-			return false;
-		}
-		const waiter = this.waiters.shift();
-		if (waiter) {
-			this.activeTask = task;
-			waiter(task);
-			return true;
-		}
-		if (this.pending.length >= this.maxQueueDepth) {
-			task.send({
-				...makeQueueOwnerError(task.requestId, `Queue owner is overloaded (${this.pending.length}/${this.maxQueueDepth} queued)`, "QUEUE_OWNER_OVERLOADED", { retryable: true }),
-				ownerGeneration: this.ownerGeneration
-			});
-			task.close();
-			return false;
-		}
-		this.pending.push(task);
-		this.emitQueueDepth();
-		return true;
-	}
-	handleControlRequest(options) {
-		this.taskSockets.add(options.socket);
-		writeQueueMessage(options.socket, {
-			type: "accepted",
-			requestId: options.requestId,
-			ownerGeneration: this.ownerGeneration
-		});
-		options.run().then((message) => {
-			writeQueueMessage(options.socket, {
-				...message,
-				ownerGeneration: this.ownerGeneration
-			});
-		}).catch((error) => {
-			writeQueueMessage(options.socket, {
-				...makeQueueOwnerErrorFromUnknown(options.requestId, error, "QUEUE_CONTROL_REQUEST_FAILED"),
-				ownerGeneration: this.ownerGeneration
-			});
-		}).finally(() => {
-			this.endSocket(options.socket);
-		});
-	}
-	endSocket(socket) {
-		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();
-		});
-	}
-	failRequest(socket, requestId, message, detailCode) {
-		writeQueueMessage(socket, {
-			...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
-			ownerGeneration: this.ownerGeneration
-		});
-		this.endSocket(socket);
-	}
-	parseRequestLine(socket, line) {
-		let parsed;
-		try {
-			parsed = JSON.parse(line);
-		} catch {
-			this.failRequest(socket, "unknown", "Invalid queue request payload", "QUEUE_REQUEST_PAYLOAD_INVALID_JSON");
-			return;
-		}
-		const request = parseQueueRequest(parsed);
-		if (!request) this.failRequest(socket, "unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
-		return request ?? void 0;
-	}
-	rejectStaleOwnerGeneration(socket, request) {
-		if (request.ownerGeneration === void 0 || this.ownerGeneration === void 0 || request.ownerGeneration === this.ownerGeneration) return false;
-		this.failRequest(socket, request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
-		return true;
-	}
-	rejectClosedOwner(socket, request) {
-		if (!this.closed) return false;
-		writeQueueMessage(socket, {
-			...makeQueueOwnerError(request.requestId, "Queue owner is shutting down", "QUEUE_OWNER_CLOSED", { retryable: true }),
-			ownerGeneration: this.ownerGeneration
-		});
-		this.endSocket(socket);
-		return true;
-	}
-	handleControlQueueRequest(socket, request) {
-		if (request.type === "cancel_prompt") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "cancel_result",
-					requestId: request.requestId,
-					cancelled: await this.cancelPrompt(request.targetRequestId)
-				})
-			});
-			return true;
-		}
-		if (request.type === "close_session") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "close_session_result",
-					requestId: request.requestId,
-					closed: await this.controlHandlers.closeSession(request.timeoutMs)
-				})
-			});
-			return true;
-		}
-		return this.handleSessionControlQueueRequest(socket, request);
-	}
-	handleSessionControlQueueRequest(socket, request) {
-		if (request.type === "set_mode") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => {
-					await this.controlHandlers.setSessionMode(request.modeId, request.timeoutMs);
-					return {
-						type: "set_mode_result",
-						requestId: request.requestId,
-						modeId: request.modeId
-					};
-				}
-			});
-			return true;
-		}
-		if (request.type === "set_model") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => {
-					const response = await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
-					return {
-						type: "set_model_result",
-						requestId: request.requestId,
-						modelId: request.modelId,
-						response
-					};
-				}
-			});
-			return true;
-		}
-		if (request.type === "set_config_option") {
-			this.handleControlRequest({
-				socket,
-				requestId: request.requestId,
-				run: async () => ({
-					type: "set_config_option_result",
-					requestId: request.requestId,
-					response: await this.controlHandlers.setSessionConfigOption(request.configId, request.value, request.timeoutMs)
-				})
-			});
-			return true;
-		}
-		return false;
-	}
-	enqueuePromptRequest(socket, request) {
-		this.taskSockets.add(socket);
-		const task = {
-			requestId: request.requestId,
-			message: request.message,
-			prompt: request.prompt ?? textPrompt(request.message),
-			permissionMode: request.permissionMode,
-			resumePolicy: request.resumePolicy,
-			nonInteractivePermissions: request.nonInteractivePermissions,
-			permissionPolicy: request.permissionPolicy,
-			timeoutMs: request.timeoutMs,
-			suppressSdkConsoleErrors: request.suppressSdkConsoleErrors,
-			promptRetries: request.promptRetries,
-			sessionOptions: request.sessionOptions,
-			waitForCompletion: request.waitForCompletion,
-			reportPromptStarted: request.reportPromptStarted,
-			enqueuedAt: Date.now(),
-			send: (message) => {
-				writeQueueMessage(socket, {
-					...message,
-					ownerGeneration: this.ownerGeneration
-				});
-			},
-			close: () => {
-				this.endSocket(socket);
-			}
-		};
-		if (!this.enqueue(task)) return;
-		writeQueueMessage(socket, {
-			type: "accepted",
-			requestId: request.requestId,
-			ownerGeneration: this.ownerGeneration
-		});
-		if (!request.waitForCompletion) task.close();
-	}
-	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);
-			this.drainingSockets.delete(socket);
-		});
-		let buffer = "";
-		let handled = false;
-		const processLine = (line) => {
-			if (handled) return;
-			handled = true;
-			const request = this.parseRequestLine(socket, line);
-			if (!request || this.rejectClosedOwner(socket, request) || this.rejectStaleOwnerGeneration(socket, request)) return;
-			if (this.handleControlQueueRequest(socket, request)) return;
-			if (request.type !== "submit_prompt") {
-				this.failRequest(socket, request.requestId, "Invalid queue request", "QUEUE_REQUEST_INVALID");
-				return;
-			}
-			this.enqueuePromptRequest(socket, request);
-		};
-		socket.on("data", (chunk) => {
-			buffer += chunk;
-			let index = buffer.indexOf("\n");
-			while (index >= 0) {
-				const rawLine = buffer.slice(0, index);
-				if (this.rejectOversizedRequest(socket, rawLine)) return;
-				const line = rawLine.trim();
-				buffer = buffer.slice(index + 1);
-				if (line.length > 0) processLine(line);
-				index = buffer.indexOf("\n");
-			}
-			this.rejectOversizedRequest(socket, buffer);
-		});
-		socket.on("error", () => {});
-	}
-	rejectOversizedRequest(socket, line) {
-		if (!queueRequestExceedsLimit(line, this.maxRequestBytes)) return false;
-		socket.destroy();
-		return true;
-	}
-};
-//#endregion
 //#region src/runtime/engine/reconnect.ts
 const SESSION_LOAD_UNSUPPORTED_CODES = /* @__PURE__ */ new Set([-32601, -32602]);
 function createReplayState(authority) {
@@ -5789,6 +5267,89 @@ async function runSessionSetConfigOptionDirect(options) {
 	};
 }
 //#endregion
+//#region src/session/execution/windows-process-command.ts
+function skipSeparators(value) {
+	return value.replace(/^[ \t]+/u, "");
+}
+function readQuote(commandLine, state, executable) {
+	if (!executable && state.quoted && commandLine[state.index + 1] === "\"") {
+		state.value += "\"";
+		state.index += 2;
+	} else {
+		state.quoted = !state.quoted;
+		state.index += 1;
+	}
+}
+function readBackslashes(commandLine, state, executable) {
+	const start = state.index;
+	while (commandLine[state.index] === "\\") state.index += 1;
+	const count = state.index - start;
+	if (executable || commandLine[state.index] !== "\"") state.value += "\\".repeat(count);
+	else {
+		state.value += "\\".repeat(Math.floor(count / 2));
+		if (count % 2 === 1) {
+			state.value += "\"";
+			state.index += 1;
+		} else readQuote(commandLine, state, false);
+	}
+}
+function readArgument(commandLine, start, executable) {
+	const state = {
+		value: "",
+		index: start,
+		quoted: false
+	};
+	while (state.index < commandLine.length) {
+		const char = commandLine[state.index];
+		if (!state.quoted && /[ \t]/u.test(char)) break;
+		if (char === "\\") readBackslashes(commandLine, state, executable);
+		else if (char === "\"") readQuote(commandLine, state, executable);
+		else {
+			state.value += char;
+			state.index += 1;
+		}
+	}
+	return state.quoted ? void 0 : state;
+}
+function readBatchCommand(commandLine) {
+	const body = commandLine.match(/^[ \t]+\/d[ \t]+\/s[ \t]+\/c[ \t]+"([\s\S]*)"$/iu)?.[1];
+	if (!body) return;
+	return readBatchExecutable(body);
+}
+function readBatchExecutable(body) {
+	let command = "";
+	for (let index = 0; index < body.length; index += 1) {
+		const char = body[index];
+		if (char === "^") {
+			index += 1;
+			if (index === body.length) return;
+			command += body[index];
+		} else if (/[ \t]/u.test(char)) break;
+		else if (/["\r\n]/u.test(char)) return;
+		else command += char;
+	}
+	return /\.(?:cmd|bat)$/iu.test(command) ? command : void 0;
+}
+/** Decode process observations, not saved command identities or POSIX launch strings. */
+function splitWindowsProcessCommandLine(commandLine) {
+	const line = skipSeparators(commandLine);
+	const executable = readArgument(line, 0, true);
+	if (!executable?.value) return [];
+	const argv = [executable.value];
+	if (path.win32.basename(executable.value).toLowerCase() === "cmd.exe") {
+		const batch = readBatchCommand(line.slice(executable.index));
+		return batch ? [...argv, batch] : argv;
+	}
+	let rest = skipSeparators(line.slice(executable.index));
+	while (rest) {
+		const argument = readArgument(rest, 0, false);
+		if (!argument) return [];
+		argv.push(argument.value);
+		rest = skipSeparators(rest.slice(argument.index));
+	}
+	return argv;
+}
+//#endregion
 //#region src/session/execution/session-control.ts
 async function cancelSessionPrompt(options) {
 	const cancelled = await tryCancelOnRunningOwner(options);
@@ -5898,15 +5459,16 @@ async function setSessionConfigOption(options) {
 		verbose: options.verbose
 	});
 }
-function firstAgentCommandToken(command) {
+function firstAgentCommandToken(command, argv) {
+	if (argv) return argv[0] || void 0;
 	try {
 		return splitCommandLine(command).command || void 0;
 	} catch {
 		return;
 	}
 }
-async function isLikelyMatchingProcess(pid, agentCommand) {
-	const expectedToken = firstAgentCommandToken(agentCommand);
+async function isLikelyMatchingProcess(pid, record) {
+	const expectedToken = firstAgentCommandToken(record.agentCommand, record.agentArgv);
 	if (!expectedToken) return false;
 	const argv = await readProcessArgv(pid);
 	if (argv.length === 0) return false;
@@ -5945,13 +5507,14 @@ async function readWindowsCommandLine(pid) {
 			"-NonInteractive",
 			"-Command",
 			`(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").CommandLine`
-		], { windowsHide: true })).trim() || void 0;
+		], { windowsHide: true })).replace(/\r?\n$/u, "") || void 0;
 	} catch {
 		return;
 	}
 }
-function splitCommandLineLike(commandLine) {
+function splitCommandLineLike(commandLine, platform = process.platform) {
 	if (!commandLine) return [];
+	if (platform === "win32") return splitWindowsProcessCommandLine(commandLine);
 	try {
 		const parsed = splitCommandLine(commandLine);
 		return [parsed.command, ...parsed.args];
@@ -5973,7 +5536,7 @@ async function closeSession(sessionId) {
 		}
 	}).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);
+	if (record.pid != null && isProcessAlive(record.pid) && await isLikelyMatchingProcess(record.pid, record)) await terminateProcess(record.pid);
 	const ownership = await acquireSessionTurn(record.acpxRecordId);
 	try {
 		const current = await resolveSessionRecord(record.acpxRecordId);
@@ -6964,10 +6527,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
 		});
 	}
@@ -7024,7 +6588,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") {
@@ -7852,6 +7416,9 @@ async function runOnce(options, control) {
 		try {
 			await closeOwnedClient();
 		} finally {
+			try {
+				options.onPermissionStats?.(client.getPermissionStats());
+			} catch {}
 			output.flush();
 		}
 	}
@@ -8291,6 +7858,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, getAcpxVersion as et, installPerfMetricsCapture as f, 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-CLwjMYNL.js.map
+//# sourceMappingURL=queue-owner-runtime-W0lly6ap.js.map