acpx 0.19.0 → 0.19.2

package/dist/{ipc-fMgj5vrO.js → ipc-D0ZMQ0q9.js}

@@ -1,5 +1,5 @@
-import { M as runTimedExecFile, n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-Ct2yWPW7.js";
-import { statSync } from "node:fs";
+import { C as PROCESS_HELPER_TIMEOUT_MS, E as isChildProcessRunning, N as runTimedExecFile, S as PROCESS_HELPER_MAX_BUFFER_BYTES, n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DWlx5BQ4.js";
+import fs, { statSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
@@ -11,6 +11,7 @@ import { createHash, randomInt, randomUUID } from "node:crypto";
 import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
 import { acquireFileLock } from "@openclaw/fs-safe/file-lock";
 import net from "node:net";
+import { resolveSecureTempRoot } from "@openclaw/fs-safe/secure-temp-root";
 //#region src/errors.ts
 var AcpxOperationalError = class extends Error {
 	outputCode;
@@ -231,12 +232,12 @@ const SESSION_RECORD_SCHEMA = "acpx.session.v1";
 //#endregion
 //#region src/acp/error-shapes.ts
 const RESOURCE_NOT_FOUND_ACP_CODES = /* @__PURE__ */ new Set([-32001, -32002]);
-function asRecord$4(value) {
+function asRecord$5(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
 function toAcpErrorPayload(value) {
-	const record = asRecord$4(value);
+	const record = asRecord$5(value);
 	if (!record) return;
 	if (typeof record.code !== "number" || !Number.isFinite(record.code)) return;
 	if (typeof record.message !== "string" || record.message.length === 0) return;
@@ -250,7 +251,7 @@ function extractAcpErrorInternal(value, depth) {
 	if (depth > 5) return;
 	const direct = toAcpErrorPayload(value);
 	if (direct) return direct;
-	const record = asRecord$4(value);
+	const record = asRecord$5(value);
 	if (!record) return;
 	return extractNestedAcpError(record, depth);
 }
@@ -285,7 +286,7 @@ function hasSessionNotFoundHint(value, depth = 0) {
 	if (depth > 4) return false;
 	if (isSessionNotFoundText(value)) return true;
 	if (Array.isArray(value)) return value.some((entry) => hasSessionNotFoundHint(entry, depth + 1));
-	const record = asRecord$4(value);
+	const record = asRecord$5(value);
 	if (!record) return false;
 	return Object.values(record).some((entry) => hasSessionNotFoundHint(entry, depth + 1));
 }
@@ -302,6 +303,136 @@ function isAcpResourceNotFoundError(error) {
 	return isSessionNotFoundText(formatUnknownErrorMessage(error));
 }
 //#endregion
+//#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$4(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$4(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$1(value) {
+	return typeof value === "string" && OUTPUT_ERROR_CODES.includes(value);
+}
+function isOutputErrorOrigin$1(value) {
+	return typeof value === "string" && OUTPUT_ERROR_ORIGINS.includes(value);
+}
+function readOutputErrorMeta(error) {
+	const record = asRecord$4(error);
+	if (!record) return {};
+	return {
+		outputCode: isOutputErrorCode$1(record.outputCode) ? record.outputCode : void 0,
+		detailCode: typeof record.detailCode === "string" && record.detailCode.trim().length > 0 ? record.detailCode : void 0,
+		origin: isOutputErrorOrigin$1(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$4(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$4(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/process-liveness.ts
 function isProcessAlive(pid) {
 	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
@@ -686,7 +817,15 @@ function parseCursor(recordId, cursor) {
 	return parsed.data[1];
 }
 function fileIdentity(stat) {
-	return `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+	return `${stat.dev}:${stat.ino}:${stat.birthtimeNs}`;
+}
+async function pathIdentity(filePath) {
+	try {
+		return fileIdentity(await fs$1.lstat(filePath, { bigint: true }));
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+		throw error;
+	}
 }
 function emptySegment() {
 	return {
@@ -718,12 +857,9 @@ var SessionJournalReader = class {
 			const segments = [];
 			try {
 				const paths = await this.openPresentSegments(segments);
-				const current = await Promise.all(paths.map((filePath) => statRegularFile(filePath)));
+				const current = await Promise.all(paths.map(pathIdentity));
 				const identities = new Map(segments.map((entry) => [entry.filePath, entry.identity]));
-				if (paths.every((filePath, index) => {
-					const entry = current[index];
-					return (entry.missing ? void 0 : fileIdentity(entry.stat)) === identities.get(filePath);
-				})) return segments;
+				if (paths.every((filePath, index) => current[index] === identities.get(filePath))) return segments;
 			} catch (error) {
 				if (!retryableSnapshotError(error)) {
 					await this.closeSnapshot(segments);
@@ -744,11 +880,16 @@ var SessionJournalReader = class {
 				symlinks: "reject",
 				nonBlockingRead: true
 			});
-			return {
-				filePath,
-				opened,
-				identity: fileIdentity(opened.stat)
-			};
+			try {
+				return {
+					filePath,
+					opened,
+					identity: fileIdentity(await opened.handle.stat({ bigint: true }))
+				};
+			} catch (error) {
+				await opened[Symbol.asyncDispose]();
+				throw error;
+			}
 		}));
 		let failure;
 		for (const result of results) if (result.status === "fulfilled") segments.push(result.value);
@@ -978,6 +1119,7 @@ async function* iterateJournal(record, options) {
 	let after = options.cursor === void 0 ? -1 : parseCursor(record.acpxRecordId, options.cursor);
 	const reader = new SessionJournalReader(record);
 	let first = true;
+	const observation = {};
 	for (;;) {
 		if (signal.aborted) return;
 		const snapshot = await settleUnlessAborted(reader.read(signal, {
@@ -992,16 +1134,34 @@ async function* iterateJournal(record, options) {
 			after = sequence;
 			yield event;
 		}
-		if (!await continueAfterPage(record, snapshot, options)) return;
+		if (!await continueAfterPage(record, snapshot, options, observation)) return;
 	}
 }
-async function continueAfterPage(record, snapshot, options) {
+async function continueAfterPage(record, snapshot, options, observation) {
+	if (options.signal.aborted || confirmsTerminalObservation(snapshot, observation)) return false;
 	if (!snapshot.hasMore && options.continueWatching) {
-		if (!await settleUnlessAborted(options.continueWatching(record, snapshot.requestId), options.signal)) return false;
+		const decision = await settleUnlessAborted(options.continueWatching(record, snapshot.requestId), options.signal).catch((error) => {
+			if (error instanceof SessionWatchError && error.code === "WATCH_OUTCOME_UNKNOWN") return error;
+			throw error;
+		});
+		if (decision !== true) {
+			observation.terminal = {
+				requestId: snapshot.requestId,
+				error: decision instanceof SessionWatchError ? decision : void 0
+			};
+			return !options.signal.aborted;
+		}
 	}
 	await settleUnlessAborted(setTimeout$1(snapshot.hasMore ? 0 : 100, void 0, { signal: options.signal }), options.signal);
 	return !options.signal.aborted;
 }
+function confirmsTerminalObservation(snapshot, observation) {
+	const terminal = observation.terminal;
+	delete observation.terminal;
+	if (!terminal || snapshot.events.length > 0 || snapshot.hasMore || snapshot.requestId !== terminal.requestId) return false;
+	if (terminal.error) throw terminal.error;
+	return true;
+}
 function assertRetainedCursor(after, snapshot, first) {
 	if (after < 0) return;
 	if (after > snapshot.sequence) throw new SessionWatchError(first ? "WATCH_CURSOR_FUTURE" : "WATCH_CURSOR_EXPIRED", "Cursor is beyond the available session journal");
@@ -1727,17 +1887,18 @@ async function readSessionRecord(sessionId) {
 		return;
 	}
 }
-function hasGitDirectory(dir) {
+function hasGitMarker(dir) {
 	const gitPath = path.join(dir, ".git");
 	try {
-		return statSync(gitPath).isDirectory();
+		const marker = statSync(gitPath);
+		return marker.isDirectory() || marker.isFile();
 	} catch {
 		return false;
 	}
 }
 function isWithinBoundary(boundary, target) {
 	const relative = path.relative(boundary, target);
-	return relative.length === 0 || !relative.startsWith("..") && !path.isAbsolute(relative);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
 function absolutePath(value) {
 	return path.resolve(value);
@@ -1746,7 +1907,7 @@ function findGitRepositoryRoot(startDir) {
 	let current = absolutePath(startDir);
 	const root = path.parse(current).root;
 	for (;;) {
-		if (hasGitDirectory(current)) return current;
+		if (hasGitMarker(current)) return current;
 		if (current === root) return;
 		const parent = path.dirname(current);
 		if (parent === current) return;
@@ -2052,6 +2213,39 @@ const LINUX_PROCESS_QUERY = `
     if (error.code === 'ENOENT') return 'unsupported';
     throw error;
   });
+  const prefix = async (name, size) => {
+    const file = await fs.open(name, 'r');
+    try {
+      const buffer = Buffer.alloc(size);
+      const { bytesRead } = await file.read(buffer, 0, size, 0);
+      return buffer.subarray(0, bytesRead).toString('base64');
+    } finally { await file.close(); }
+  };
+  const targets = async () => {
+    if (targetPid !== 'all') {
+      return { targetStat: await fs.readFile('/proc/' + targetPid + '/stat', 'utf8').catch(() => null) };
+    }
+    const required = new Set(JSON.parse(process.argv[3] || '[]'));
+    const pids = new Set((await fs.readdir('/proc')).filter(pid => /^[1-9][0-9]*$/.test(pid)));
+    for (const pid of required) pids.add(String(pid));
+    const processStats = [];
+    let bytes = 0;
+    // Sequential reads keep proc I/O and retained memory bounded within this
+    // single killable helper; never launch one helper or pending read per PID.
+    for (const pid of [...pids].sort((a, b) => Number(a) - Number(b))) {
+      let stat;
+      try { stat = await fs.readFile('/proc/' + pid + '/stat', 'utf8'); }
+      catch (error) {
+        if (error.code === 'ENOENT' || error.code === 'ESRCH') continue;
+        if (!required.has(Number(pid)) && (error.code === 'EACCES' || error.code === 'EPERM')) continue;
+        throw error;
+      }
+      bytes += Buffer.byteLength(JSON.stringify(stat)) + 1;
+      if (bytes > ${PROCESS_HELPER_MAX_BUFFER_BYTES} - 8192) throw new Error('Process table exceeds its byte limit');
+      processStats.push(stat);
+    }
+    return { processStats, auxv: await prefix('/proc/self/auxv', 4096), elf: await prefix('/proc/self/exe', 6) };
+  };
   Promise.all([
     fs.readFile('/proc/sys/kernel/random/boot_id', 'utf8'),
     fs.readlink('/proc/self/ns/pid'),
@@ -2059,12 +2253,12 @@ const LINUX_PROCESS_QUERY = `
     fs.readlink('/proc/' + observerPid + '/ns/pid'),
     timeNamespace(observerPid),
     fs.readFile('/proc/self/stat', 'utf8'),
-    fs.readFile('/proc/' + targetPid + '/stat', 'utf8').catch(() => null),
+    targets(),
   ]).then(([bootId, pidNamespace, timeNamespace, observerPidNamespace,
-    observerTimeNamespace, selfStat, targetStat]) => {
+    observerTimeNamespace, selfStat, target]) => {
     process.stdout.write(JSON.stringify({bootId: bootId.trim(), pidNamespace,
       timeNamespace, observerPidNamespace, observerTimeNamespace,
-      helperPid: process.pid, selfStat, targetStat}));
+      helperPid: process.pid, selfStat, ...target}));
   }).catch(() => { process.exitCode = 1; });
 `;
 const POSIX_MONTHS = [
@@ -2146,31 +2340,48 @@ function parseLinuxStat(raw) {
 	const pid = Number(prefix[1]);
 	const fields = raw.slice(close + 2).trim().split(/\s+/u);
 	const startTicks = fields[19];
-	if (!isPositivePid(pid) || !isStartTicks(startTicks) || !/^[RSDTtKWPI]$/.test(fields[0] ?? "")) return;
-	return {
+	if (!isPositivePid(pid) || !isStartTicks(startTicks) || !/^[RSDTtKWPI]$/.test(fields[0])) return;
+	const parentPid = Number(fields[1]);
+	const groupPid = Number(fields[2]);
+	return validProcessLinks(parentPid, groupPid) ? {
 		pid,
+		parentPid,
+		groupPid,
 		startTicks
-	};
+	} : void 0;
 }
-async function readLinuxObservation(pid, timeoutMs) {
-	const output = await runTimedExecFile(process.execPath, [
+function validProcessLinks(parentPid, groupPid) {
+	return Number.isSafeInteger(parentPid) && parentPid >= 0 && Number.isSafeInteger(groupPid) && groupPid >= 0;
+}
+async function readLinuxQuery(pid, timeoutMs, requiredPids = []) {
+	const args = [
 		"--input-type=commonjs",
 		"-e",
 		LINUX_PROCESS_QUERY,
 		String(pid),
 		String(process.pid)
-	], {
+	];
+	if (pid === "all") args.push(JSON.stringify(requiredPids));
+	const output = await runTimedExecFile(process.execPath, args, {
 		timeoutMs,
-		maxBufferBytes: 8192,
+		maxBufferBytes: pid === "all" ? PROCESS_HELPER_MAX_BUFFER_BYTES : 8192,
 		env: {
 			...process.env,
 			NODE_OPTIONS: ""
 		}
 	});
-	const raw = JSON.parse(output);
+	return JSON.parse(output);
+}
+function verifiedLinuxScope(raw) {
 	const scope = parseLinuxScope(raw);
 	const self = parseLinuxStat(raw.selfStat);
 	if (!scope || !self || self.pid !== raw.helperPid || scope.pidNamespace !== raw.observerPidNamespace || scope.timeNamespace !== raw.observerTimeNamespace) return;
+	return scope;
+}
+async function readLinuxObservation(pid, timeoutMs) {
+	const raw = await readLinuxQuery(pid, timeoutMs);
+	const scope = verifiedLinuxScope(raw);
+	if (!scope) return;
 	const target = parseLinuxStat(raw.targetStat);
 	return {
 		scope,
@@ -2181,6 +2392,80 @@ async function readLinuxObservation(pid, timeoutMs) {
 		} } : {}
 	};
 }
+function linuxAuxv(raw) {
+	if (typeof raw.elf !== "string" || typeof raw.auxv !== "string") throw new Error("Linux process clock is unavailable");
+	const elf = Buffer.from(raw.elf, "base64");
+	const auxv = Buffer.from(raw.auxv, "base64");
+	if (elf.subarray(0, 4).toString("hex") !== "7f454c46" || ![1, 2].includes(elf[4]) || ![1, 2].includes(elf[5])) throw new Error("Linux process clock has an invalid ELF format");
+	return {
+		auxv,
+		size: elf[4] === 1 ? 4 : 8,
+		littleEndian: elf[5] === 1
+	};
+}
+function linuxClockTicks(raw) {
+	const { auxv, size, littleEndian } = linuxAuxv(raw);
+	const word = (offset) => readAuxvWord(auxv, offset, size, littleEndian);
+	for (let offset = 0; offset + size * 2 <= auxv.length; offset += size * 2) {
+		const key = word(offset);
+		if (key === 0n) break;
+		if (key === 17n && word(offset + size) > 0n) return word(offset + size);
+	}
+	throw new Error("Linux process clock has no AT_CLKTCK");
+}
+function readAuxvWord(buffer, offset, size, littleEndian) {
+	if (size === 8) return littleEndian ? buffer.readBigUInt64LE(offset) : buffer.readBigUInt64BE(offset);
+	return BigInt(littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset));
+}
+async function readLinuxProcessTable(timeoutMs, requiredPids, pid) {
+	const raw = await readLinuxQuery("all", timeoutMs, requiredPids);
+	const scope = verifiedLinuxScope(raw);
+	if (!scope || !Array.isArray(raw.processStats)) throw new Error("Linux process table scope is unverified");
+	const clockTicksPerSecond = linuxClockTicks(raw);
+	const table = /* @__PURE__ */ new Map();
+	for (const value of raw.processStats) {
+		const stat = parseLinuxStat(value);
+		if (stat && (pid === void 0 || stat.pid === pid)) table.set(stat.pid, {
+			pid: stat.pid,
+			parentPid: stat.parentPid,
+			groupPid: stat.groupPid,
+			birth: {
+				kind: "linux-proc",
+				...scope,
+				startTicks: stat.startTicks
+			},
+			clockTicksPerSecond
+		});
+	}
+	return table;
+}
+function readLinuxExitClock() {
+	let descriptor;
+	try {
+		descriptor = fs.openSync("/proc/uptime", "r");
+		const buffer = Buffer.alloc(64);
+		const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+		const match = /^(\d+)\.(\d{2})\s/u.exec(buffer.toString("ascii", 0, bytes));
+		return match ? {
+			centiseconds: BigInt(match[1]) * 100n + BigInt(match[2]),
+			timeNamespace: readOwnTimeNamespace()
+		} : void 0;
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== void 0) try {
+			fs.closeSync(descriptor);
+		} catch {}
+	}
+}
+function readOwnTimeNamespace() {
+	try {
+		return fs.readlinkSync("/proc/self/ns/time");
+	} catch (error) {
+		if (error.code === "ENOENT") return "unsupported";
+		throw error;
+	}
+}
 function isPositivePid(pid) {
 	return Number.isSafeInteger(pid) && pid > 0;
 }
@@ -2218,7 +2503,7 @@ function parseProcessTable(output) {
 			pid,
 			parentPid: Number(match[2]),
 			groupPid: Number(match[3]),
-			birth
+			birth: processBirthIdentity(birth)
 		});
 	}
 	return table;
@@ -2227,7 +2512,7 @@ function processTableBirth(value) {
 	if (process.platform !== "win32") return posixBirth(value);
 	return isCanonicalBirth(value, "windows-creation") ? value : void 0;
 }
-async function readProcessTable(timeoutMs, pid) {
+async function readProcessTable(timeoutMs, pid, requiredPids = []) {
 	if (pid !== void 0 && (!Number.isSafeInteger(pid) || pid <= 0)) throw new Error("Process identity requires a positive PID");
 	if (process.platform === "win32") return parseProcessTable(await runTimedExecFile(windowsPowerShellPath(), [
 		"-NoLogo",
@@ -2239,6 +2524,7 @@ async function readProcessTable(timeoutMs, pid) {
 		timeoutMs,
 		windowsHide: true
 	}));
+	if (process.platform === "linux") return await readLinuxProcessTable(timeoutMs, requiredPids, pid);
 	return parseProcessTable(await runTimedExecFile("ps", [
 		...pid === void 0 ? ["-e"] : ["-p", String(pid)],
 		"-o",
@@ -2266,8 +2552,7 @@ async function probeProcessIdentity(pid, timeoutMs = IDENTITY_QUERY_TIMEOUT_MS$1
 }
 async function readNativeIdentity(pid, timeoutMs) {
 	if (process.platform === "linux") return (await readLinuxObservation(pid, timeoutMs))?.identity;
-	const entry = (await readProcessTable(timeoutMs, pid)).get(pid);
-	return entry ? processBirthIdentity(entry.birth) : void 0;
+	return (await readProcessTable(timeoutMs, pid)).get(pid)?.birth;
 }
 function processBirthIdentity(value) {
 	return {
@@ -2314,6 +2599,138 @@ async function getOwnProcessIdentity() {
 	return await ownIdentityPending;
 }
 //#endregion
+//#region src/acp/process-descendants.ts
+function hasStaleWindowsParent(identity, parent) {
+	return identity.birth.kind === "windows-creation" && (parent?.birth.kind !== "windows-creation" || parent.birth.value > identity.birth.value);
+}
+function includeProcessDescendants(table, owned) {
+	let expanded;
+	do {
+		expanded = false;
+		for (const identity of table.values()) {
+			if (hasStaleWindowsParent(identity, table.get(identity.parentPid))) 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 = process.platform === "linux" ? readLinuxExitClock() ?? null : 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, void 0, this.requiredSnapshotPids(rootWasRunning));
+			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;
+		}
+	}
+	requiredSnapshotPids(rootWasRunning) {
+		return [...this.identities.keys(), ...rootWasRunning && this.child.pid ? [this.child.pid] : []];
+	}
+	refresh(table, rootWasRunning) {
+		this.verifyScope(table);
+		const owned = /* @__PURE__ */ new Set();
+		for (const [pid, identity] of this.identities) {
+			const observed = table.get(pid);
+			if (observed && compareProcessBirthIdentity(identity.birth, observed.birth) === "matching") owned.add(pid);
+		}
+		this.includeRoot(table, owned);
+		if (this.ownProcessGroup) this.includeProcessGroup(table, owned, rootWasRunning);
+		includeProcessDescendants(table, owned);
+		owned.delete(this.child.pid ?? 0);
+		this.identities = new Map([...table].filter(([pid]) => owned.has(pid)));
+	}
+	verifyScope(table) {
+		const expected = this.rootBirth ?? this.identities.values().next().value?.birth;
+		const observation = table.values().next().value?.birth;
+		if (expected && observation && compareProcessBirthIdentity(expected, observation) === "unknown") throw new Error("Descendant process scope changed");
+	}
+	includeRoot(table, owned) {
+		const root = this.child.pid;
+		const rootIdentity = root && table.get(root);
+		if (rootIdentity && isChildProcessRunning(this.child)) {
+			this.rootBirth ??= rootIdentity.birth;
+			if (compareProcessBirthIdentity(this.rootBirth, rootIdentity.birth) === "matching") 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.startedBeforeRootExit(identity)) owned.add(identity.pid);
+		}
+	}
+	startedBeforeRootExit(identity) {
+		const cutoff = this.groupExitedAt;
+		if (cutoff === void 0) return true;
+		if (cutoff === null) return false;
+		if (identity.birth.kind !== "linux-proc") return typeof cutoff === "number" && Date.parse(identity.birth.value) <= cutoff;
+		if (typeof cutoff === "number" || identity.birth.timeNamespace !== cutoff.timeNamespace || !identity.clockTicksPerSecond) return false;
+		return BigInt(identity.birth.startTicks) * 100n < (cutoff.centiseconds + 1n) * identity.clockTicksPerSecond;
+	}
+	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 = performance.now() + timeoutMs;
+		do {
+			if (!await this.capture(Math.max(1, deadline - performance.now()))) return false;
+			if (this.identities.size === 0) return true;
+			await setTimeout$1(Math.min(100, Math.max(0, deadline - performance.now())));
+		} while (performance.now() < deadline);
+		return false;
+	}
+	retire() {
+		this.retired = true;
+		this.child.off("exit", this.onRootExit);
+		this.identities.clear();
+	}
+};
+//#endregion
 //#region src/session/lock-owner.ts
 const OBSERVATION_REUSE_MS = 1e3;
 const IDENTITY_QUERY_TIMEOUT_MS = 1e3;
@@ -2377,6 +2794,145 @@ function queueSocketPath(sessionId, homeDir = os.homedir()) {
 	return path.join(queueSocketBaseDir(homeDir) ?? "/tmp", `${key}.sock`);
 }
 //#endregion
+//#region src/session/queue/retirement-receipt.ts
+const MAX_RETIREMENT_MEMBERS = 4096;
+const MAX_RETIREMENT_BYTES = 1048576;
+function hasQueueRetirementReceipt(value) {
+	return value !== null && typeof value === "object" && Object.hasOwn(value, "retirement");
+}
+function parseWitness(raw) {
+	if (!raw || typeof raw !== "object") return;
+	const value = raw;
+	const processIdentity = parseProcessBirthIdentity(value.processIdentity);
+	if (typeof value.pid !== "number" || !Number.isSafeInteger(value.pid) || value.pid <= 1 || processIdentity?.kind !== "windows-creation") return;
+	return {
+		pid: value.pid,
+		processIdentity
+	};
+}
+function parseQueueRetirementReceipt(raw, owner) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const value = raw;
+	const root = parseReceiptRoot(value, owner);
+	if (!root) return null;
+	const descendants = parseDescendants(value.descendants, root.pid);
+	if (!descendants) return null;
+	try {
+		if (Buffer.byteLength(JSON.stringify(raw)) > MAX_RETIREMENT_BYTES) return null;
+	} catch {
+		return null;
+	}
+	return {
+		ownerGeneration: owner.ownerGeneration,
+		root,
+		descendants
+	};
+}
+function parseReceiptRoot(value, owner) {
+	const root = parseWitness(value.root);
+	if (!root || root.pid !== owner.pid || value.ownerGeneration !== owner.ownerGeneration || compareProcessBirthIdentity(owner.processIdentity, root.processIdentity) !== "matching") return;
+	return root;
+}
+function parseDescendants(raw, rootPid) {
+	if (!Array.isArray(raw) || raw.length >= MAX_RETIREMENT_MEMBERS) return;
+	const pids = /* @__PURE__ */ new Set([rootPid]);
+	const witnesses = [];
+	for (const value of raw) {
+		const witness = parseWitness(value);
+		if (!witness || pids.has(witness.pid)) return;
+		pids.add(witness.pid);
+		witnesses.push(witness);
+	}
+	return witnesses;
+}
+function queueRetirementIncomplete() {
+	return new QueueConnectionError("Queue-owner descendant cleanup is incomplete or unverified. Its lease was retained. Retry cleanup with updated clients and process-query access; do not remove the lease while recorded processes may remain.", {
+		detailCode: "QUEUE_OWNER_RETIREMENT_INCOMPLETE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function retirementTimeRemaining(deadline, maximumMs = 2e3) {
+	const remaining = deadline - performance.now();
+	if (remaining <= 0) throw queueRetirementIncomplete();
+	return Math.min(maximumMs, remaining);
+}
+async function readRetirementSnapshot(deadline) {
+	if (process.platform !== "win32") throw queueRetirementIncomplete();
+	return await readProcessTable(retirementTimeRemaining(deadline)).catch(() => {
+		throw queueRetirementIncomplete();
+	});
+}
+function observeRetirementSnapshot(witness, table) {
+	if (process.platform !== "win32" || !isWindowsRetirementIdentity(witness.processIdentity)) return "unknown";
+	const observed = table?.get(witness.pid);
+	const comparison = observed ? compareProcessBirthIdentity(witness.processIdentity, observed.birth) : "unknown";
+	if (comparison === "different" || isProcessDefinitelyDead(witness.pid)) return "gone";
+	return witness.pid === process.pid ? "unknown" : comparison;
+}
+function isWindowsRetirementIdentity(identity) {
+	return identity === void 0 || identity.kind === "windows-creation";
+}
+function captureQueueRetirementReceipt(owner, previous, rootRunning, snapshot) {
+	const root = parseWitness({
+		pid: owner.pid,
+		processIdentity: owner.processIdentity
+	});
+	if (!root || process.platform !== "win32") throw queueRetirementIncomplete();
+	const saved = previous ? previous.descendants : [];
+	const table = new Map(snapshot);
+	const owned = matchingSnapshotPids(table, rootRunning ? [root, ...saved] : saved);
+	if (rootRunning && !owned.has(root.pid)) throw queueRetirementIncomplete();
+	table.delete(1);
+	table.delete(process.pid);
+	includeProcessDescendants(table, owned);
+	owned.delete(root.pid);
+	const receipt = {
+		ownerGeneration: owner.ownerGeneration,
+		root,
+		descendants: unsettledSnapshotWitnesses(snapshot, mergeSnapshotDescendants(table, owned, saved))
+	};
+	if (!parseQueueRetirementReceipt(receipt, owner)) throw queueRetirementIncomplete();
+	return receipt;
+}
+function unsettledSnapshotWitnesses(table, witnesses) {
+	return witnesses.filter((witness) => {
+		const observed = table.get(witness.pid);
+		return !observed || compareProcessBirthIdentity(witness.processIdentity, observed.birth) !== "different";
+	});
+}
+function matchingSnapshotPids(table, witnesses) {
+	const owned = /* @__PURE__ */ new Set();
+	for (const witness of witnesses) {
+		const observed = table.get(witness.pid);
+		if (observed && compareProcessBirthIdentity(witness.processIdentity, observed.birth) === "matching") owned.add(witness.pid);
+	}
+	return owned;
+}
+function mergeSnapshotDescendants(table, owned, saved) {
+	const descendants = new Map(saved.map((witness) => [witness.pid, witness]));
+	for (const pid of owned) {
+		const observed = table.get(pid);
+		if (observed) descendants.set(pid, {
+			pid,
+			processIdentity: observed.birth
+		});
+	}
+	return [...descendants.values()];
+}
+async function observeRetirementWitness(witness, deadline) {
+	if (witness.pid === process.pid) throw queueRetirementIncomplete();
+	return await observeProcessIncarnation(witness.pid, witness.processIdentity, retirementTimeRemaining(deadline));
+}
+async function assertQueueRetirementComplete(receipt, deadline) {
+	if (receipt === null) throw queueRetirementIncomplete();
+	const witnesses = receipt?.descendants ?? [];
+	if (witnesses.length === 0) return;
+	const live = witnesses.filter((witness) => observeRetirementSnapshot(witness, void 0) !== "gone");
+	const table = live.length > 0 ? await readRetirementSnapshot(deadline) : void 0;
+	for (const witness of live) if (observeRetirementSnapshot(witness, table) !== "gone") throw queueRetirementIncomplete();
+}
+//#endregion
 //#region src/session/queue/lease-mutation.ts
 const GUARD_WAIT_MS = 2e3;
 const localMutations = /* @__PURE__ */ new Map();
@@ -2432,7 +2988,7 @@ async function rollbackReservation(lockPath, expected) {
 		} catch {
 			return;
 		}
-		if (matchesReservation(value, expected)) await fs$1.unlink(lockPath);
+		if (matchesReservation(value, expected) && !hasQueueRetirementReceipt(value)) await fs$1.unlink(lockPath);
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
@@ -2537,7 +3093,7 @@ function parseQueueOwnerRecord(raw) {
 	const record = raw;
 	if (!hasValidQueueOwnerRecordFields(record)) return null;
 	const processIdentity = parseProcessBirthIdentity(record.processIdentity);
-	return {
+	const owner = {
 		pid: record.pid,
 		sessionId: record.sessionId,
 		socketPath: record.socketPath,
@@ -2550,6 +3106,8 @@ function parseQueueOwnerRecord(raw) {
 		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
 		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
 	};
+	if (hasQueueRetirementReceipt(record)) owner.retirement = parseQueueRetirementReceipt(record.retirement, owner);
+	return owner;
 }
 function parseQueueOwnerCapabilities(record) {
 	return {
@@ -2611,20 +3169,21 @@ async function removeSocketFile(socketPath) {
 	}
 }
 async function waitForProcessExit(pid, timeoutMs, hasExited) {
-	const deadline = Date.now() + Math.max(0, timeoutMs);
-	while (Date.now() <= deadline) {
+	const deadline = performance.now() + Math.max(0, timeoutMs);
+	while (performance.now() <= deadline) {
 		if (hasExited(pid)) return true;
 		await waitMs(PROCESS_POLL_MS);
 	}
 	return hasExited(pid);
 }
-async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent, capturedIdentity) {
+async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent, capturedIdentity, deadline = retirementDeadline()) {
 	await withQueueLeaseMutation(sessionId, async () => {
-		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent);
+		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent, deadline);
 	}, { capturedIdentity });
 }
-async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent, deadline = retirementDeadline()) {
 	if (!await isCurrent()) return;
+	await assertQueueRetirementComplete((await readQueueOwnerRecord(sessionId))?.retirement, deadline);
 	await removeSocketFile(socketPath).catch(() => {});
 	if (!await isCurrent()) return;
 	await fs$1.unlink(queueLockFilePath(sessionId)).catch((error) => {
@@ -2640,6 +3199,9 @@ function matchesQueueOwner(current, expected) {
 function ownerIsAlive(owner) {
 	return owner.pid === process.pid || isProcessAlive(owner.pid);
 }
+function ownerAcceptsWork(owner) {
+	return owner.retirement === void 0 && ownerIsAlive(owner) && !isQueueOwnerHeartbeatStale(owner);
+}
 async function readQueueOwnerRecord(sessionId) {
 	const lockPath = queueLockFilePath(sessionId);
 	try {
@@ -2665,7 +3227,7 @@ function dispatchSignal(pid, signal) {
 		return false;
 	}
 }
-async function dispatchQueueOwnerSignal(pid, signal) {
+async function dispatchQueueOwnerSignal(pid, signal, deadline) {
 	if (process.platform !== "win32") return dispatchSignal(pid, signal);
 	const systemRoot = process.env.SystemRoot;
 	if (!systemRoot || !path.win32.isAbsolute(systemRoot)) throw new Error("Windows queue-owner cleanup requires an absolute SystemRoot directory");
@@ -2676,15 +3238,15 @@ async function dispatchQueueOwnerSignal(pid, signal) {
 		"/T",
 		"/F"
 	], {
-		timeoutMs: PROCESS_SIGTERM_GRACE_MS,
+		timeoutMs: retirementTimeRemaining(deadline, PROCESS_SIGTERM_GRACE_MS),
 		windowsHide: true
 	});
 	return true;
 }
-async function terminateWithDispatch(pid, dispatch, hasExited) {
+async function terminateWithDispatch(pid, dispatch, hasExited, deadline = Infinity) {
 	for (const [signal, graceMs] of [["SIGTERM", PROCESS_SIGTERM_GRACE_MS], ["SIGKILL", PROCESS_SIGKILL_GRACE_MS]]) {
 		if (!await dispatch(signal)) return false;
-		if (await waitForProcessExit(pid, graceMs, hasExited)) return true;
+		if (await waitForProcessExit(pid, Math.min(graceMs, deadline - performance.now()), hasExited)) return true;
 	}
 	return false;
 }
@@ -2692,10 +3254,10 @@ async function resolveUsableQueueOwner(sessionId, owner) {
 	await settlePendingQueueLeaseGuard(sessionId);
 	const observed = await readQueueOwnerRecord(sessionId);
 	if (!matchesQueueOwner(observed, owner)) return;
-	if (ownerIsAlive(observed) && !isQueueOwnerHeartbeatStale(observed)) return observed;
+	if (ownerAcceptsWork(observed)) return observed;
 	await terminateQueueOwnerForSession(sessionId, observed, true);
 	const current = await readQueueOwnerRecord(sessionId);
-	return matchesQueueOwner(current, observed) && ownerIsAlive(current) && !isQueueOwnerHeartbeatStale(current) ? current : void 0;
+	return matchesQueueOwner(current, observed) && ownerAcceptsWork(current) ? current : void 0;
 }
 async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, nowIsoFactory = nowIso) {
 	const { mcpConfigPath, clock } = resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory);
@@ -2806,9 +3368,13 @@ function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 	if (lease.released) return Promise.resolve();
 	const update = lease.updates.then(async () => {
 		await withQueueLeaseMutation(lease.sessionId, async () => {
-			if (!await ownsQueueLease(lease)) return;
-			await stageQueueOwnerRecord(lease, options.queueDepth, nowIsoFactory, async (tempPath) => {
-				await fs$1.rename(tempPath, lease.lockPath);
+			const current = await readQueueOwnerRecord(lease.sessionId);
+			if (!matchesQueueOwner(current, lease)) return;
+			if (current.retirement === null) throw queueRetirementIncomplete();
+			await replaceQueueOwnerRecord({
+				...current,
+				heartbeatAt: nowIsoFactory(),
+				queueDepth: Math.max(0, Math.round(options.queueDepth))
 			});
 		}, { capturedIdentity: lease });
 	});
@@ -2816,8 +3382,8 @@ function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 	return update;
 }
 async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
-	const payload = JSON.stringify({
-		pid: process.pid,
+	await stagePreparedQueueOwnerRecord({
+		pid: lease.pid,
 		sessionId: lease.sessionId,
 		socketPath: lease.socketPath,
 		createdAt: lease.createdAt,
@@ -2830,9 +3396,17 @@ async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 		persistsControlState: true,
 		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
 		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
-	}, null, 2);
+	}, publish);
+}
+async function replaceQueueOwnerRecord(owner) {
+	await stagePreparedQueueOwnerRecord(owner, async (tempPath) => {
+		await fs$1.rename(tempPath, queueLockFilePath(owner.sessionId));
+	});
+}
+async function stagePreparedQueueOwnerRecord(owner, publish) {
+	const payload = JSON.stringify(owner, null, 2);
 	await withTempFile({
-		rootDir: path.dirname(lease.lockPath),
+		rootDir: path.dirname(queueLockFilePath(owner.sessionId)),
 		prefix: "owner",
 		fileName: "lease"
 	}, async (tempPath) => {
@@ -2856,40 +3430,166 @@ function unverifiedQueueOwnerError(owner) {
 		retryable: true
 	});
 }
-async function dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement) {
-	return await withQueueLeaseMutation(owner.sessionId, async () => {
-		const current = await readQueueOwnerRecord(owner.sessionId);
-		retirement.leaseReleased = current?.pid !== owner.pid;
-		if (!matchesQueueOwner(current, owner) || requireStale && signal === "SIGTERM" && !isQueueOwnerHeartbeatStale(current)) return false;
-		const identity = await observeProcessIncarnation(current.pid, current.processIdentity);
-		if (identity !== "matching") {
-			retirement.gone = identity === "gone";
-			retirement.unverified = identity === "unknown";
-			return false;
-		}
-		return await dispatchQueueOwnerSignal(owner.pid, signal);
-	});
+function retirementDeadline() {
+	return performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
 }
-async function retireQueueOwner(owner, requireStale) {
-	const deadline = performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
-	const retirement = {
+async function createQueueOwnerRetirement(deadline) {
+	const snapshot = process.platform === "win32" ? await readRetirementSnapshot(deadline).catch(() => void 0) : void 0;
+	return {
 		gone: false,
 		unverified: false,
-		leaseReleased: false
+		leaseReleased: false,
+		deadline,
+		snapshot,
+		capturedIdentity: process.platform === "win32" ? { processIdentity: snapshot?.get(process.pid)?.birth } : void 0
 	};
-	await terminateWithDispatch(owner.pid, (signal) => dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement), isProcessDefinitelyDead);
-	if (retirement.unverified && requireStale) throw unverifiedQueueOwnerError(owner);
-	if (retirement.leaseReleased || retirement.unverified) await waitForProcessExit(owner.pid, Math.max(0, deadline - performance.now()), isProcessDefinitelyDead);
-	const gone = retirement.gone || await observeProcessIncarnation(owner.pid, owner.processIdentity) === "gone";
+}
+async function observeRetiringOwner(owner, deadline) {
+	return await observeProcessIncarnation(owner.pid, owner.processIdentity, process.platform === "win32" ? retirementTimeRemaining(deadline) : void 0);
+}
+function retirementBlockedByHeartbeat(owner, signal, requireStale) {
+	return requireStale && owner.retirement === void 0 && signal === "SIGTERM" && !isQueueOwnerHeartbeatStale(owner);
+}
+async function prepareWindowsRetirement(owner, table, deadline) {
+	if (owner.retirement === null || !table) throw queueRetirementIncomplete();
+	owner.retirement = captureQueueRetirementReceipt(owner, owner.retirement, true, table);
+	await replaceQueueOwnerRecord(owner);
+	return await observeRetirementWitness(owner.retirement.root, deadline);
+}
+async function prepareRetiringOwner(owner, signal, retirement) {
+	const windows = process.platform === "win32";
+	const table = windows && signal !== "SIGTERM" ? await readRetirementSnapshot(retirement.deadline) : retirement.snapshot;
+	let identity = windows ? observeRetirementSnapshot(owner, table) : await observeRetiringOwner(owner, retirement.deadline);
+	if (identity === "matching" && windows) identity = await prepareWindowsRetirement(owner, table, retirement.deadline);
+	retirement.gone = identity === "gone";
+	retirement.unverified = identity === "unknown";
+	return identity === "matching";
+}
+async function dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement) {
+	return await withQueueLeaseMutation(owner.sessionId, async () => {
+		const current = await readQueueOwnerRecord(owner.sessionId);
+		retirement.leaseReleased = current?.pid !== owner.pid;
+		if (!matchesQueueOwner(current, owner) || retirementBlockedByHeartbeat(current, signal, requireStale)) return false;
+		if (current.retirement === null) throw queueRetirementIncomplete();
+		if (!await prepareRetiringOwner(current, signal, retirement)) return false;
+		return await dispatchQueueOwnerSignal(owner.pid, signal, retirement.deadline);
+	}, { capturedIdentity: retirement.capturedIdentity });
+}
+async function retireQueueOwner(owner, requireStale, retirement) {
+	const { deadline } = retirement;
+	const exited = await terminateWithDispatch(owner.pid, (signal) => dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement), isProcessDefinitelyDead, process.platform === "win32" ? deadline : Infinity);
+	if (await waitForReleasedOwner(owner, requireStale, retirement)) return false;
+	const gone = retirement.gone || process.platform === "win32" && exited || await observeRetiringOwner(owner, deadline) === "gone";
 	if (retirement.unverified && !gone) throw unverifiedQueueOwnerError(owner);
 	return gone;
 }
+async function waitForReleasedOwner(owner, requireStale, retirement) {
+	if (retirement.unverified && requireStale) throw unverifiedQueueOwnerError(owner);
+	if (retirement.leaseReleased || retirement.unverified) {
+		await waitForProcessExit(owner.pid, Math.max(0, retirement.deadline - performance.now()), isProcessDefinitelyDead);
+		if (performance.now() >= retirement.deadline) {
+			if (retirement.unverified) throw unverifiedQueueOwnerError(owner);
+			return true;
+		}
+	}
+	return false;
+}
+async function retireRecordedDescendants(owner, retirement) {
+	await withQueueLeaseMutation(owner.sessionId, async () => {
+		const current = await readQueueOwnerRecord(owner.sessionId);
+		if (!matchesQueueOwner(current, owner) || current.retirement === void 0) return;
+		if (current.retirement === null || process.platform !== "win32") throw queueRetirementIncomplete();
+		await retireSnapshotDescendants(current, current.retirement, retirement.deadline);
+	}, { capturedIdentity: retirement.capturedIdentity });
+}
+function hasNewRetirementWitness(previous, receipt) {
+	const saved = new Map(previous.descendants.map((witness) => [witness.pid, witness.processIdentity]));
+	return receipt.descendants.some((witness) => compareProcessBirthIdentity(saved.get(witness.pid), witness.processIdentity) !== "matching");
+}
+async function retireSnapshotDescendants(owner, receipt, deadline) {
+	while (receipt.descendants.length > 0) {
+		const table = await readRetirementSnapshot(deadline);
+		const discovered = captureQueueRetirementReceipt(owner, receipt, false, table);
+		if (hasNewRetirementWitness(receipt, discovered)) {
+			receipt = discovered;
+			owner.retirement = receipt;
+			await replaceQueueOwnerRecord(owner);
+			continue;
+		}
+		signalRecordedDescendants(discovered, table, deadline);
+		await waitForRecordedDescendants(discovered, deadline);
+		discovered.descendants = discovered.descendants.filter((witness) => !isProcessDefinitelyDead(witness.pid));
+		receipt = discovered;
+		owner.retirement = receipt;
+		await replaceQueueOwnerRecord(owner);
+	}
+}
+function leafFirstRetirementWitnesses(receipt, table) {
+	const children = new Map(receipt.descendants.map((witness) => [witness.pid, 0]));
+	for (const witness of receipt.descendants) {
+		const parent = retirementParent(witness.pid, table);
+		const count = children.get(parent);
+		if (count !== void 0) children.set(parent, count + 1);
+	}
+	const pending = receipt.descendants.filter((witness) => children.get(witness.pid) === 0);
+	const byPid = new Map(receipt.descendants.map((witness) => [witness.pid, witness]));
+	for (let index = 0; index < pending.length; index += 1) {
+		const parent = retirementParent(pending[index].pid, table);
+		const count = children.get(parent);
+		if (count !== void 0) {
+			const remaining = count - 1;
+			children.set(parent, remaining);
+			if (remaining === 0) pending.push(byPid.get(parent));
+		}
+	}
+	if (pending.length !== receipt.descendants.length) throw queueRetirementIncomplete();
+	return pending;
+}
+function retirementParent(pid, table) {
+	const identity = table.get(pid);
+	return identity && !hasStaleWindowsParent(identity, table.get(identity.parentPid)) ? identity.parentPid : 0;
+}
+function signalRecordedDescendants(receipt, table, deadline) {
+	if (receipt.descendants.some((witness) => observeRetirementSnapshot(witness, table) === "unknown")) throw queueRetirementIncomplete();
+	const ordered = leafFirstRetirementWitnesses(receipt, table);
+	let failure;
+	for (const witness of ordered) {
+		if (observeRetirementSnapshot(witness, table) !== "matching") continue;
+		retirementTimeRemaining(deadline);
+		try {
+			process.kill(witness.pid, "SIGKILL");
+		} catch (error) {
+			if (!isProcessDefinitelyDead(witness.pid)) failure ??= error;
+		}
+	}
+	if (failure) throw failure;
+}
+async function waitForRecordedDescendants(receipt, deadline) {
+	for (let waited = 0; waited < 1e3; waited += PROCESS_POLL_MS) {
+		if (receipt.descendants.every((witness) => isProcessDefinitelyDead(witness.pid))) return;
+		await waitMs(Math.min(PROCESS_POLL_MS, retirementTimeRemaining(deadline)));
+	}
+}
+async function assertNoPendingRetirement(owner) {
+	const current = await readQueueOwnerRecord(owner.sessionId);
+	if (matchesQueueOwner(current, owner) && current.retirement !== void 0) throw queueRetirementIncomplete();
+}
 async function terminateQueueOwnerForSession(sessionId, expectedOwner, requireStale = false) {
 	await settlePendingQueueLeaseGuard(sessionId);
 	const owner = expectedOwner ?? await readQueueOwnerRecord(sessionId);
-	if (!owner || owner.sessionId !== sessionId || owner.pid === process.pid) return;
-	if (!await retireQueueOwner(owner, requireStale)) return;
-	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner));
+	if (!owner || owner.sessionId !== sessionId) return;
+	if (owner.pid === process.pid) {
+		if (owner.retirement !== void 0) throw queueRetirementIncomplete();
+		return;
+	}
+	const deadline = retirementDeadline();
+	const retirement = await createQueueOwnerRetirement(deadline);
+	if (!await retireQueueOwner(owner, requireStale, retirement)) {
+		await assertNoPendingRetirement(owner);
+		return;
+	}
+	await retireRecordedDescendants(owner, retirement);
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner), retirement.capturedIdentity, deadline);
 }
 async function waitMs(ms) {
 	await new Promise((resolve) => {
@@ -3294,9 +3994,12 @@ function queueOwnerMessageParser(type) {
 }
 function parseEventOwnerMessage(message, context) {
 	if (!isAcpJsonRpcMessage(message.message)) return null;
+	const direction = message.direction;
+	if (direction !== void 0 && direction !== "inbound" && direction !== "outbound") return null;
 	return {
 		type: "event",
 		...context,
+		...direction === void 0 ? {} : { direction },
 		message: message.message
 	};
 }
@@ -3391,6 +4094,610 @@ function assertQueueRequestSize(line) {
 	});
 }
 //#endregion
+//#region src/session/queue/socket-output.ts
+const OUTPUT_CHUNK_BYTES = 65536;
+const DRAIN_TIMEOUT_MS = 1e3;
+const DEFAULT_LIMITS = Object.freeze({
+	observerBytes: 67108864,
+	totalBytes: 268435456,
+	observers: 64
+});
+var QueueOutputBudget = class {
+	limits;
+	bytes = 0;
+	files = 0;
+	observers = 0;
+	constructor(limits = DEFAULT_LIMITS) {
+		this.limits = limits;
+	}
+	acquire() {
+		if (this.files >= this.limits.observers) throw new Error("Queue output spool descriptor limit reached");
+		this.files += 1;
+	}
+	grow(bytes) {
+		if (bytes > this.limits.totalBytes - this.bytes) throw new Error("Queue output spool storage limit reached");
+		this.bytes += bytes;
+	}
+	release(bytes) {
+		this.bytes -= bytes;
+		this.files -= 1;
+	}
+	acquireObserver() {
+		if (this.observers >= this.limits.observers) throw new Error("Queue blocked observer limit reached");
+		this.observers += 1;
+	}
+	releaseObserver() {
+		this.observers -= 1;
+	}
+};
+var OutputRing = class {
+	budget;
+	fd;
+	physicalBytes = 0;
+	readOffset = 0;
+	length = 0;
+	constructor(budget) {
+		this.budget = budget;
+		budget.acquire();
+		try {
+			const root = resolveSecureTempRoot({ fallbackPrefix: "acpx-output" });
+			const file = path.join(root, `${randomUUID()}.tmp`);
+			this.fd = fs.openSync(file, "wx+", 384);
+			fs.unlinkSync(file);
+		} catch (error) {
+			if (this.fd === void 0) budget.release(0);
+			else this.close();
+			throw error;
+		}
+	}
+	append(bytes, offset) {
+		const capacity = this.budget.limits.observerBytes;
+		if (bytes.length - offset > capacity - this.length) throw new Error("Queue observer output backlog limit reached");
+		while (offset < bytes.length) {
+			const position = (this.readOffset + this.length) % capacity;
+			const count = Math.min(OUTPUT_CHUNK_BYTES, bytes.length - offset, capacity - position);
+			const growth = Math.max(0, position + count - this.physicalBytes);
+			this.budget.grow(growth);
+			this.physicalBytes += growth;
+			const written = fs.writeSync(this.fd, bytes, offset, count, position);
+			if (written <= 0) throw new Error("Queue output spool write made no progress");
+			offset += written;
+			this.length += written;
+		}
+	}
+	read() {
+		const capacity = this.budget.limits.observerBytes;
+		const bytes = Buffer.allocUnsafeSlow(Math.min(OUTPUT_CHUNK_BYTES, this.length, capacity - this.readOffset));
+		let offset = 0;
+		while (offset < bytes.length) {
+			const read = fs.readSync(this.fd, bytes, offset, bytes.length - offset, this.readOffset + offset);
+			if (read <= 0) throw new Error("Queue output spool ended before its committed bytes");
+			offset += read;
+		}
+		this.readOffset = (this.readOffset + bytes.length) % capacity;
+		this.length -= bytes.length;
+		return bytes;
+	}
+	close() {
+		const fd = this.fd;
+		this.fd = void 0;
+		if (fd !== void 0) {
+			fs.closeSync(fd);
+			this.budget.release(this.physicalBytes);
+		}
+	}
+};
+var QueueSocketOutput = class {
+	socket;
+	budget;
+	ring;
+	blocked = false;
+	ending = false;
+	disposed = false;
+	reserved = false;
+	pendingWrites = 0;
+	constructor(socket, budget) {
+		this.socket = socket;
+		this.budget = budget;
+		socket.on("drain", this.onDrain);
+		socket.once("close", () => {
+			this.disposed = true;
+			socket.off("drain", this.onDrain);
+			this.closeSpool();
+			this.releaseObserver();
+		});
+	}
+	send(message) {
+		if (this.ending || this.socket.destroyed || !this.socket.writable) return;
+		try {
+			this.writeFrame(Buffer.from(`${JSON.stringify(message)}\n`));
+		} catch (error) {
+			this.fail(error);
+		}
+	}
+	writeFrame(bytes) {
+		let offset = 0;
+		while (!this.blocked && offset < bytes.length) {
+			const end = Math.min(offset + OUTPUT_CHUNK_BYTES, bytes.length);
+			const chunk = Buffer.allocUnsafeSlow(end - offset);
+			bytes.copy(chunk, 0, offset, end);
+			this.write(chunk);
+			offset = end;
+		}
+		if (offset < bytes.length) {
+			this.ring ??= new OutputRing(this.budget);
+			this.ring.append(bytes, offset);
+		}
+	}
+	end() {
+		if (this.ending || this.socket.destroyed) return;
+		this.ending = true;
+		this.armTimeout();
+		this.finishIfDrained();
+	}
+	write(bytes) {
+		if (!this.reserved) {
+			this.budget.acquireObserver();
+			this.reserved = true;
+		}
+		this.pendingWrites += 1;
+		try {
+			this.blocked = !this.socket.write(bytes, this.onWrite);
+		} catch (error) {
+			this.pendingWrites -= 1;
+			throw error;
+		}
+		if (this.blocked && !this.socket.timeout) this.armTimeout();
+	}
+	onWrite = (error) => {
+		this.pendingWrites -= 1;
+		if (this.disposed) return;
+		if (error) {
+			this.fail(error);
+			return;
+		}
+		this.releaseIfIdle();
+	};
+	armTimeout() {
+		if (process.platform !== "win32") this.socket.setTimeout(DRAIN_TIMEOUT_MS);
+	}
+	onDrain = () => {
+		if (this.disposed) return;
+		this.blocked = false;
+		if (!this.ending) this.socket.setTimeout(0);
+		try {
+			this.pump();
+			this.releaseIfIdle();
+			this.finishIfDrained();
+		} catch (error) {
+			this.fail(error);
+		}
+	};
+	pump() {
+		while (!this.blocked && this.ring && this.ring.length > 0) this.write(this.ring.read());
+		if (this.ring?.length === 0) this.closeSpool();
+	}
+	finishIfDrained() {
+		if (this.ending && !this.ring?.length && !this.socket.writableEnded) this.socket.end(() => this.socket.destroy());
+	}
+	releaseObserver() {
+		if (this.reserved) {
+			this.reserved = false;
+			this.budget.releaseObserver();
+		}
+	}
+	releaseIfIdle() {
+		if (this.pendingWrites === 0 && !this.blocked && !this.ring?.length) this.releaseObserver();
+	}
+	closeSpool() {
+		const ring = this.ring;
+		this.ring = void 0;
+		try {
+			ring?.close();
+		} catch (error) {
+			this.socket.destroy(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	fail(error) {
+		this.disposed = true;
+		this.socket.destroy(error instanceof Error ? error : new Error(String(error)));
+		this.closeSpool();
+	}
+};
+//#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
+	};
+}
+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();
+	outputBudget = new QueueOutputBudget();
+	outputs = /* @__PURE__ */ new Map();
+	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);
+		this.writeQueueMessage(options.socket, {
+			type: "accepted",
+			requestId: options.requestId,
+			ownerGeneration: this.ownerGeneration
+		});
+		options.run().then((message) => {
+			this.writeQueueMessage(options.socket, {
+				...message,
+				ownerGeneration: this.ownerGeneration
+			});
+		}).catch((error) => {
+			this.writeQueueMessage(options.socket, {
+				...makeQueueOwnerErrorFromUnknown(options.requestId, error, "QUEUE_CONTROL_REQUEST_FAILED"),
+				ownerGeneration: this.ownerGeneration
+			});
+		}).finally(() => {
+			this.endSocket(options.socket);
+		});
+	}
+	writeQueueMessage(socket, message) {
+		this.outputs.get(socket)?.send(message);
+	}
+	endSocket(socket) {
+		if (socket.destroyed || this.drainingSockets.has(socket)) return;
+		this.taskSockets.delete(socket);
+		this.drainingSockets.add(socket);
+		this.outputs.get(socket)?.end();
+	}
+	failRequest(socket, requestId, message, detailCode) {
+		this.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;
+		this.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) => {
+				this.writeQueueMessage(socket, {
+					...message,
+					ownerGeneration: this.ownerGeneration
+				});
+			},
+			close: () => {
+				this.endSocket(socket);
+			}
+		};
+		if (!this.enqueue(task)) return;
+		this.writeQueueMessage(socket, {
+			type: "accepted",
+			requestId: request.requestId,
+			ownerGeneration: this.ownerGeneration
+		});
+		if (!request.waitForCompletion) task.close();
+	}
+	handleConnection(socket) {
+		this.sockets.add(socket);
+		this.outputs.set(socket, new QueueSocketOutput(socket, this.outputBudget));
+		socket.setEncoding("utf8");
+		socket.on("timeout", () => socket.destroy());
+		socket.once("close", () => {
+			this.outputs.delete(socket);
+			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/session/queue/ipc.ts
 const MAX_MESSAGE_BUFFER_SIZE = 10485760;
 function assertOwnerGeneration(owner, message) {
@@ -3578,7 +4885,7 @@ function unexpectedQueueResponseError() {
 }
 function handleAcknowledgedSubmitMessage(message, controls, formatter) {
 	if (message.type === "event") {
-		notifyObserver(() => formatter.onAcpMessage(message.message));
+		notifyObserver(() => formatter.onAcpMessage(message.message, message.direction));
 		return;
 	}
 	if (message.type === "permission_escalation") {
@@ -3861,6 +5168,6 @@ async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, time
 	});
 }
 //#endregion
-export { measurePerf as $, findGitRepositoryRoot as A, PERMISSION_POLICY_ACTIONS as At, writeSessionRecord as B, PermissionDeniedError as Bt, getUnsupportedPromptContentMessage as C, AUTH_POLICIES as Ct, textPrompt as D, OUTPUT_ERROR_ORIGINS as Dt, promptToDisplayText as E, OUTPUT_ERROR_CODES as Et, listSessionsForAgent as F, AgentStartupError as Ft, normalizeAgentSessionId as G, SessionModelReplayError as Gt, parseSessionRecord as H, QueueConnectionError as Ht, normalizeName as I, AuthPolicyError as It, SessionWatchError as J, UnsupportedPromptContentError as Jt, SESSION_JOURNAL_SCHEMA as K, SessionNotFoundError as Kt, pruneSessions as L, ClaudeAcpSessionCreateTimeoutError as Lt, findSessionByDirectoryWalk as M, AcpxOperationalError as Mt, isoNow as N, AgentDisconnectedError as Nt, DEFAULT_HISTORY_LIMIT as O, OUTPUT_FORMATS as Ot, listSessions as P, AgentSpawnError as Pt, incrementPerfCounter as Q, readSessionRecord as R, CopilotAcpUnsupportedError as Rt, PromptInputValidationError as S, isAcpResourceNotFoundError as St, parsePromptSource as T, NON_INTERACTIVE_PERMISSION_POLICIES as Tt, serializeSessionRecordForDisk as U, SessionConfigOptionReplayError as Ut, assertPersistedKeyPolicy as V, PermissionPromptUnavailableError as Vt, extractAgentSessionId as W, SessionModeReplayError as Wt, formatPerfMetric as X, watchSession as Y, getPerfMetricsSnapshot as Z, waitMs as _, writePrivateFile as _t, trySetModelOnRunningOwner as a, isAcpJsonRpcMessage as at, lockOwnerPid as b, extractAcpError as bt, queueRequestExceedsLimit as c, parseJsonRpcErrorMessage as ct, readQueueOwnerRecord as d, DEFAULT_EVENT_SEGMENT_MAX_BYTES as dt, recordPerfDuration as et, refreshQueueOwnerLease as f, defaultSessionEventLog as ft, tryAcquireQueueOwnerLease as g, sessionEventSegmentPath as gt, terminateQueueOwnerForSession as h, sessionEventLockPath as ht, trySetModeOnRunningOwner as i, extractSessionUpdateNotification as it, findSession as j, SESSION_RECORD_SCHEMA as jt, absolutePath as k, PERMISSION_MODES as kt, parseQueueRequest as l, parsePermissionNotice as lt, terminateProcess as m, sessionEventActivePath as mt, tryCloseSessionOnRunningOwner as n, setPerfGauge as nt, trySubmitToRunningOwner as o, isAcpMessageObject as ot, releaseQueueOwnerLease as p, sessionBaseDir as pt, SessionJournalReader as q, SessionResumeRequiredError as qt, trySetConfigOptionOnRunningOwner as r, startPerfTimer as rt, queueRequestByteLimit as s, isSessionUpdateNotification as st, tryCancelOnRunningOwner as t, resetPerfMetrics as tt, probeQueueOwnerHealth as u, parsePromptStopReason as ut, QueueLeaseGuardSettlementError as v, writePrivateJsonFile as vt, mergePromptSourceWithText as w, EXIT_CODES as wt, readProcessTable as x, formatUnknownErrorMessage as xt, createLockOwner as y, isProcessAlive as yt, resolveSessionRecord as z, GeminiAcpStartupTimeoutError as zt };
+export { resetPerfMetrics as $, findSession as A, PERMISSION_POLICY_ACTIONS as At, assertPersistedKeyPolicy as B, PermissionDeniedError as Bt, mergePromptSourceWithText as C, extractAcpError as Ct, DEFAULT_HISTORY_LIMIT as D, NON_INTERACTIVE_PERMISSION_POLICIES as Dt, textPrompt as E, EXIT_CODES as Et, normalizeName as F, AgentStartupError as Ft, SESSION_JOURNAL_SCHEMA as G, SessionModelReplayError as Gt, serializeSessionRecordForDisk as H, QueueConnectionError as Ht, pruneSessions as I, AuthPolicyError as It, watchSession as J, UnsupportedPromptContentError as Jt, SessionJournalReader as K, SessionNotFoundError as Kt, readSessionRecord as L, ClaudeAcpSessionCreateTimeoutError as Lt, isoNow as M, AcpxOperationalError as Mt, listSessions as N, AgentDisconnectedError as Nt, absolutePath as O, OUTPUT_FORMATS as Ot, listSessionsForAgent as P, AgentSpawnError as Pt, measurePerf as Q, resolveSessionRecord as R, CopilotAcpUnsupportedError as Rt, getUnsupportedPromptContentMessage as S, normalizeOutputError as St, promptToDisplayText as T, AUTH_POLICIES as Tt, extractAgentSessionId as U, SessionConfigOptionReplayError as Ut, parseSessionRecord as V, PermissionPromptUnavailableError as Vt, normalizeAgentSessionId as W, SessionModeReplayError as Wt, getPerfMetricsSnapshot as X, formatPerfMetric as Y, incrementPerfCounter as Z, createLockOwner as _, isProcessAlive as _t, trySetModelOnRunningOwner as a, isSessionUpdateNotification as at, observeProcessIncarnation as b, isAcpQueryClosedBeforeResponseError as bt, probeQueueOwnerHealth as c, parsePromptStopReason as ct, releaseQueueOwnerLease as d, sessionBaseDir as dt, setPerfGauge as et, terminateProcess as f, sessionEventActivePath as ft, QueueLeaseGuardSettlementError as g, writePrivateJsonFile as gt, waitMs as h, writePrivateFile as ht, trySetModeOnRunningOwner as i, isAcpMessageObject as it, findSessionByDirectoryWalk as j, SESSION_RECORD_SCHEMA as jt, findGitRepositoryRoot as k, PERMISSION_MODES as kt, readQueueOwnerRecord as l, DEFAULT_EVENT_SEGMENT_MAX_BYTES as lt, tryAcquireQueueOwnerLease as m, sessionEventSegmentPath as mt, tryCloseSessionOnRunningOwner as n, extractSessionUpdateNotification as nt, trySubmitToRunningOwner as o, parseJsonRpcErrorMessage as ot, terminateQueueOwnerForSession as p, sessionEventLockPath as pt, SessionWatchError as q, SessionResumeRequiredError as qt, trySetConfigOptionOnRunningOwner as r, isAcpJsonRpcMessage as rt, SessionQueueOwner as s, parsePermissionNotice as st, tryCancelOnRunningOwner as t, startPerfTimer as tt, refreshQueueOwnerLease as u, defaultSessionEventLog as ut, lockOwnerPid as v, exitCodeForOutputErrorCode as vt, parsePromptSource as w, isAcpResourceNotFoundError as wt, PromptInputValidationError as x, isRetryablePromptError as xt, ProcessDescendants as y, formatErrorMessage as yt, writeSessionRecord as z, GeminiAcpStartupTimeoutError as zt };
 
-//# sourceMappingURL=ipc-fMgj5vrO.js.map
+//# sourceMappingURL=ipc-D0ZMQ0q9.js.map