acpx 0.19.1 → 0.19.2

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

@@ -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");
@@ -2697,16 +2857,30 @@ function retirementTimeRemaining(deadline, maximumMs = 2e3) {
 	if (remaining <= 0) throw queueRetirementIncomplete();
 	return Math.min(maximumMs, remaining);
 }
-async function captureQueueRetirementReceipt(owner, previous, rootRunning, deadline) {
+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 table = await readProcessTable(retirementTimeRemaining(deadline)).catch(() => {
-		throw queueRetirementIncomplete();
-	});
-	const saved = unsettledSnapshotWitnesses(table, previous ? previous.descendants : []);
+	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);
@@ -2716,7 +2890,7 @@ async function captureQueueRetirementReceipt(owner, previous, rootRunning, deadl
 	const receipt = {
 		ownerGeneration: owner.ownerGeneration,
 		root,
-		descendants: mergeSnapshotDescendants(table, owned, saved)
+		descendants: unsettledSnapshotWitnesses(snapshot, mergeSnapshotDescendants(table, owned, saved))
 	};
 	if (!parseQueueRetirementReceipt(receipt, owner)) throw queueRetirementIncomplete();
 	return receipt;
@@ -2752,7 +2926,11 @@ async function observeRetirementWitness(witness, deadline) {
 }
 async function assertQueueRetirementComplete(receipt, deadline) {
 	if (receipt === null) throw queueRetirementIncomplete();
-	for (const witness of receipt?.descendants ?? []) if (await observeRetirementWitness(witness, deadline) !== "gone") 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
@@ -3255,17 +3433,37 @@ function unverifiedQueueOwnerError(owner) {
 function retirementDeadline() {
 	return performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
 }
+async function createQueueOwnerRetirement(deadline) {
+	const snapshot = process.platform === "win32" ? await readRetirementSnapshot(deadline).catch(() => void 0) : void 0;
+	return {
+		gone: false,
+		unverified: false,
+		leaseReleased: false,
+		deadline,
+		snapshot,
+		capturedIdentity: process.platform === "win32" ? { processIdentity: snapshot?.get(process.pid)?.birth } : void 0
+	};
+}
 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, deadline) {
-	if (owner.retirement === null) throw queueRetirementIncomplete();
-	owner.retirement = await captureQueueRetirementReceipt(owner, owner.retirement, true, deadline);
+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) === "matching";
+	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 () => {
@@ -3273,26 +3471,15 @@ async function dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, ret
 		retirement.leaseReleased = current?.pid !== owner.pid;
 		if (!matchesQueueOwner(current, owner) || retirementBlockedByHeartbeat(current, signal, requireStale)) return false;
 		if (current.retirement === null) throw queueRetirementIncomplete();
-		const identity = await observeRetiringOwner(current, retirement.deadline);
-		if (identity !== "matching") {
-			retirement.gone = identity === "gone";
-			retirement.unverified = identity === "unknown";
-			return false;
-		}
-		if (process.platform === "win32" && !await prepareWindowsRetirement(current, retirement.deadline)) return false;
+		if (!await prepareRetiringOwner(current, signal, retirement)) return false;
 		return await dispatchQueueOwnerSignal(owner.pid, signal, retirement.deadline);
-	});
+	}, { capturedIdentity: retirement.capturedIdentity });
 }
-async function retireQueueOwner(owner, requireStale, deadline) {
-	const retirement = {
-		gone: false,
-		unverified: false,
-		leaseReleased: false,
-		deadline
-	};
-	await terminateWithDispatch(owner.pid, (signal) => dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement), isProcessDefinitelyDead, process.platform === "win32" ? deadline : Infinity);
+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 || await observeRetiringOwner(owner, deadline) === "gone";
+	const gone = retirement.gone || process.platform === "win32" && exited || await observeRetiringOwner(owner, deadline) === "gone";
 	if (retirement.unverified && !gone) throw unverifiedQueueOwnerError(owner);
 	return gone;
 }
@@ -3307,44 +3494,80 @@ async function waitForReleasedOwner(owner, requireStale, retirement) {
 	}
 	return false;
 }
-async function retireRecordedDescendants(owner, deadline) {
+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();
-		if (current.retirement.descendants.length === 0) return;
-		current.retirement = await captureQueueRetirementReceipt(current, current.retirement, false, deadline);
-		await replaceQueueOwnerRecord(current);
-		await signalRecordedDescendants(current.retirement, deadline);
-		await waitForRecordedDescendants(current.retirement, deadline);
-	});
-}
-async function hasSurvivingRetirementDescendant(receipt, deadline) {
-	for (const witness of receipt.descendants) {
-		const state = await observeRetirementWitness(witness, deadline);
-		if (state === "unknown") throw queueRetirementIncomplete();
-		if (state === "matching") return true;
+		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);
 	}
-	return false;
 }
-async function signalRecordedDescendants(receipt, deadline) {
+function leafFirstRetirementWitnesses(receipt, table) {
+	const children = new Map(receipt.descendants.map((witness) => [witness.pid, 0]));
 	for (const witness of receipt.descendants) {
-		const state = await observeRetirementWitness(witness, deadline);
-		if (state === "unknown") throw queueRetirementIncomplete();
-		if (state === "matching") {
-			retirementTimeRemaining(deadline);
-			try {
-				process.kill(witness.pid, "SIGKILL");
-			} catch (error) {
-				if (await observeRetirementWitness(witness, deadline) !== "gone") throw error;
-			}
+		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) {
-	while (true) {
-		if (!await hasSurvivingRetirementDescendant(receipt, deadline)) return;
-		await waitMs(Math.min(1e3, retirementTimeRemaining(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) {
@@ -3360,12 +3583,13 @@ async function terminateQueueOwnerForSession(sessionId, expectedOwner, requireSt
 		return;
 	}
 	const deadline = retirementDeadline();
-	if (!await retireQueueOwner(owner, requireStale, deadline)) {
+	const retirement = await createQueueOwnerRetirement(deadline);
+	if (!await retireQueueOwner(owner, requireStale, retirement)) {
 		await assertNoPendingRetirement(owner);
 		return;
 	}
-	await retireRecordedDescendants(owner, deadline);
-	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner), void 0, deadline);
+	await retireRecordedDescendants(owner, retirement);
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner), retirement.capturedIdentity, deadline);
 }
 async function waitMs(ms) {
 	await new Promise((resolve) => {
@@ -3870,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) {
@@ -4340,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, ProcessDescendants 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-DAApJ5mi.js.map
+//# sourceMappingURL=ipc-D0ZMQ0q9.js.map