acpx 0.19.1 → 0.19.3

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

@@ -1,4 +1,4 @@
-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 { 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-DWnqUICY.js";
 import fs, { statSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -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,7 @@ var SessionJournalReader = class {
 			const segments = [];
 			try {
 				const paths = await this.openPresentSegments(segments);
-				const current = await Promise.all(paths.map((filePath) => statRegularFile(filePath)));
-				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 (await this.matchesSnapshot(paths, segments)) return segments;
 			} catch (error) {
 				if (!retryableSnapshotError(error)) {
 					await this.closeSnapshot(segments);
@@ -744,11 +878,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);
@@ -759,10 +898,33 @@ var SessionJournalReader = class {
 	async closeSnapshot(segments) {
 		await Promise.all(segments.map(({ opened }) => opened[Symbol.asyncDispose]()));
 	}
+	async matchesSnapshot(paths, segments) {
+		const current = await Promise.all(paths.map(pathIdentity));
+		const identities = new Map(segments.map((entry) => [entry.filePath, entry.identity]));
+		return paths.every((filePath, index) => current[index] === identities.get(filePath));
+	}
+	async withSnapshot(read, signal) {
+		for (;;) {
+			const segments = await this.openSnapshot(signal);
+			try {
+				const outcome = await read(segments).then((value) => ({ value }), (error) => {
+					if (!(error instanceof SessionWatchError) || error.code !== "WATCH_JOURNAL_CORRUPT") throw error;
+					return { error };
+				});
+				if (await this.matchesSnapshot(this.paths(), segments)) {
+					signal?.throwIfAborted();
+					if ("error" in outcome) throw outcome.error;
+					return outcome.value;
+				}
+			} finally {
+				await this.closeSnapshot(segments);
+			}
+			await setTimeout$1(5, void 0, { signal });
+		}
+	}
 	async readAcpMessages() {
-		const segments = await this.openSnapshot();
-		const messages = [];
-		try {
+		return await this.withSnapshot(async (segments) => {
+			const messages = [];
 			for (const { opened } of segments) {
 				const payload = await opened.handle.readFile("utf8");
 				for (const line of payload.split("\n")) try {
@@ -771,15 +933,12 @@ var SessionJournalReader = class {
 				} catch {}
 			}
 			return messages;
-		} finally {
-			await this.closeSnapshot(segments);
-		}
+		});
 	}
 	async readTail() {
-		const segments = await this.openSnapshot();
-		let tail = emptySegment();
-		let active = emptySegment();
-		try {
+		return await this.withSnapshot(async (segments) => {
+			let tail = emptySegment();
+			let active = emptySegment();
 			for (const segment of segments.toReversed()) {
 				const state = emptySegment();
 				await this.readSegment(segment.opened.handle, segment.opened.stat.size, state, void 0);
@@ -797,22 +956,20 @@ var SessionJournalReader = class {
 				activeAnchored: active.firstSequence !== void 0,
 				activePartial: active.pending.length > 0
 			};
-		} finally {
-			await this.closeSnapshot(segments);
-		}
+		});
 	}
 	async read(signal, options) {
-		const page = createJournalPage(options);
-		const segments = await this.openSnapshot(signal);
-		let hasMore = false;
-		let firstSequence;
-		let tail = emptySegment();
-		let active = emptySegment();
-		try {
+		const { result, states } = await this.withSnapshot(async (segments) => {
+			const page = createJournalPage(options);
+			const states = new Map(this.states);
+			let hasMore = false;
+			let firstSequence;
+			let tail = emptySegment();
+			let active = emptySegment();
 			for (const segment of segments) {
-				const state = this.states.get(segment.identity) ?? emptySegment();
+				const state = { ...states.get(segment.identity) ?? emptySegment() };
 				await this.readSegment(segment.opened.handle, segment.opened.stat.size, state, page, signal);
-				this.states.set(segment.identity, state);
+				states.set(segment.identity, state);
 				if (state.firstSequence !== void 0) {
 					if (firstSequence === void 0) firstSequence = state.firstSequence;
 					else if (state.firstSequence !== tail.sequence) corrupt("Session journal segments are not contiguous");
@@ -824,25 +981,29 @@ var SessionJournalReader = class {
 					break;
 				}
 			}
-			this.pruneStates(segments);
+			this.pruneStates(states, segments);
 			return {
-				events: page.events,
-				hasMore,
-				firstSequence,
-				sequence: tail.sequence,
-				messageSequence: tail.messageSequence,
-				requestId: tail.requestId,
-				activeSize: active.offset,
-				activeAnchored: active.firstSequence !== void 0,
-				activePartial: active.pending.length > 0
+				states,
+				result: {
+					events: page.events,
+					hasMore,
+					firstSequence,
+					sequence: tail.sequence,
+					messageSequence: tail.messageSequence,
+					requestId: tail.requestId,
+					activeSize: active.offset,
+					activeAnchored: active.firstSequence !== void 0,
+					activePartial: active.pending.length > 0
+				}
 			};
-		} finally {
-			await this.closeSnapshot(segments);
-		}
+		}, signal);
+		signal?.throwIfAborted();
+		this.states = states;
+		return result;
 	}
-	pruneStates(segments) {
+	pruneStates(states, segments) {
 		const retained = new Set(segments.map((entry) => entry.identity));
-		for (const identity of this.states.keys()) if (!retained.has(identity)) this.states.delete(identity);
+		for (const identity of states.keys()) if (!retained.has(identity)) states.delete(identity);
 	}
 	async readSegment(handle, size, state, page, signal) {
 		if (size < state.offset) corrupt("Session journal was truncated while watching");
@@ -978,6 +1139,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 +1154,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");
@@ -1238,12 +1418,15 @@ function parseRequestTokenUsage(raw) {
 	}
 	return usage;
 }
+function isValidImageSize(size) {
+	if (size === void 0 || size === null) return true;
+	const record = asRecord$2(size);
+	return !!record && isFiniteNumber(record.width) && isFiniteNumber(record.height);
+}
 function isSessionMessageImage(raw) {
 	const record = asRecord$2(raw);
-	if (!record || typeof record.source !== "string") return false;
-	if (record.size === void 0 || record.size === null) return true;
-	const size = asRecord$2(record.size);
-	return !!size && isFiniteNumber(size.width) && isFiniteNumber(size.height);
+	if (!record || typeof record.source !== "string" || !isOptionalString(record.mime_type)) return false;
+	return isValidImageSize(record.size);
 }
 function isSessionMessageAudio(raw) {
 	const record = asRecord$2(raw);
@@ -1867,182 +2050,6 @@ async function unlinkCountingBytes(filePath) {
 	return bytes;
 }
 //#endregion
-//#region src/prompt-content.ts
-var PromptInputValidationError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "PromptInputValidationError";
-	}
-};
-function asRecord$1(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	return value;
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.trim().length > 0;
-}
-function isBase64Data(value) {
-	if (value.length === 0 || value.length % 4 !== 0) return false;
-	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
-}
-function isImageMimeType(value) {
-	return /^image\/[A-Za-z0-9.+-]+$/i.test(value);
-}
-function isAudioMimeType(value) {
-	return /^audio\/[A-Za-z0-9.+-]+$/i.test(value);
-}
-function isTextBlock(value) {
-	const record = asRecord$1(value);
-	return record?.type === "text" && typeof record.text === "string";
-}
-function isImageBlock(value) {
-	const record = asRecord$1(value);
-	return record?.type === "image" && isNonEmptyString(record.mimeType) && isImageMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
-}
-function isAudioBlock(value) {
-	const record = asRecord$1(value);
-	return record?.type === "audio" && isNonEmptyString(record.mimeType) && isAudioMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
-}
-function isResourceLinkBlock(value) {
-	const record = asRecord$1(value);
-	return record?.type === "resource_link" && isNonEmptyString(record.uri) && (record.title == null || typeof record.title === "string") && typeof record.name === "string";
-}
-function isResourcePayload(value) {
-	const record = asRecord$1(value);
-	if (!record || !isNonEmptyString(record.uri)) return false;
-	return typeof record.text === "string" || typeof record.blob === "string";
-}
-function isResourceBlock(value) {
-	const record = asRecord$1(value);
-	return record?.type === "resource" && isResourcePayload(record.resource);
-}
-const CONTENT_BLOCK_VALIDATORS = [
-	isTextBlock,
-	isImageBlock,
-	isAudioBlock,
-	isResourceLinkBlock,
-	isResourceBlock
-];
-function isContentBlock(value) {
-	return CONTENT_BLOCK_VALIDATORS.some((validator) => validator(value));
-}
-const CONTENT_BLOCK_ERROR_VALIDATORS = {
-	text: validateTextContentBlock,
-	image: validateImageContentBlock,
-	audio: validateAudioContentBlock,
-	resource_link: validateResourceLinkContentBlock,
-	resource: validateResourceContentBlock
-};
-function contentBlockErrorValidator(type) {
-	return Object.hasOwn(CONTENT_BLOCK_ERROR_VALIDATORS, type) ? CONTENT_BLOCK_ERROR_VALIDATORS[type] : void 0;
-}
-function validateTextContentBlock(record, index) {
-	return typeof record.text === "string" ? void 0 : `prompt[${index}] text block must include a string text field`;
-}
-function validateImageContentBlock(record, index) {
-	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] image block must include a non-empty mimeType`;
-	if (!isImageMimeType(record.mimeType)) return `prompt[${index}] image block mimeType must start with image/`;
-	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] image block must include non-empty base64 data`;
-	return isBase64Data(record.data) ? void 0 : `prompt[${index}] image block data must be valid base64`;
-}
-function validateAudioContentBlock(record, index) {
-	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] audio block must include a non-empty mimeType`;
-	if (!isAudioMimeType(record.mimeType)) return `prompt[${index}] audio block mimeType must start with audio/`;
-	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] audio block must include non-empty base64 data`;
-	return isBase64Data(record.data) ? void 0 : `prompt[${index}] audio block data must be valid base64`;
-}
-function validateResourceLinkContentBlock(record, index) {
-	if (!isNonEmptyString(record.uri)) return `prompt[${index}] resource_link block must include a non-empty uri`;
-	if (record.title != null && typeof record.title !== "string") return `prompt[${index}] resource_link block title must be a string or null when present`;
-	if (typeof record.name !== "string") return `prompt[${index}] resource_link block must include a string name`;
-}
-function validateResourceContentBlock(record, index) {
-	if (!asRecord$1(record.resource)) return `prompt[${index}] resource block must include a resource object`;
-	return isResourcePayload(record.resource) ? void 0 : `prompt[${index}] resource block resource must include a non-empty uri and a string text or blob field`;
-}
-function getContentBlockValidationError(value, index) {
-	const record = asRecord$1(value);
-	if (!record || typeof record.type !== "string") return `prompt[${index}] must be an ACP content block object`;
-	const validator = contentBlockErrorValidator(record.type);
-	return validator ? validator(record, index) : `prompt[${index}] has unsupported content block type ${JSON.stringify(record.type)}`;
-}
-function isPromptInput(value) {
-	return Array.isArray(value) && value.every((entry) => isContentBlock(entry));
-}
-function promptCapabilityRequirement(block) {
-	switch (block.type) {
-		case "image": return {
-			blockType: "image",
-			capability: "image"
-		};
-		case "audio": return {
-			blockType: "audio",
-			capability: "audio"
-		};
-		case "resource": return {
-			blockType: "resource",
-			capability: "embeddedContext"
-		};
-		default: return;
-	}
-}
-function getUnsupportedPromptContentMessage(prompt, agentCapabilities) {
-	for (const [index, block] of prompt.entries()) {
-		const requirement = promptCapabilityRequirement(block);
-		if (!requirement) continue;
-		if (agentCapabilities?.promptCapabilities?.[requirement.capability] === true) continue;
-		return `prompt[${index}] ${requirement.blockType} content requires agentCapabilities.promptCapabilities.${requirement.capability}`;
-	}
-}
-function textPrompt(text) {
-	return [{
-		type: "text",
-		text
-	}];
-}
-function parseStructuredPrompt(source) {
-	if (!source.startsWith("[")) return;
-	try {
-		const parsed = JSON.parse(source);
-		if (isPromptInput(parsed)) return parsed;
-		if (Array.isArray(parsed)) throw new PromptInputValidationError(parsed.map((entry, index) => getContentBlockValidationError(entry, index)).find((message) => message !== void 0) ?? "Structured prompt JSON must be an array of valid ACP content blocks");
-		return;
-	} catch (error) {
-		if (error instanceof PromptInputValidationError) throw error;
-		return;
-	}
-}
-function parsePromptSource(source) {
-	const trimmed = source.trim();
-	const structured = parseStructuredPrompt(trimmed);
-	if (structured) return structured;
-	if (!trimmed) return [];
-	return textPrompt(trimmed);
-}
-function mergePromptSourceWithText(source, suffixText) {
-	const prompt = parsePromptSource(source);
-	const appended = suffixText.trim();
-	if (!appended) return prompt;
-	if (prompt.length === 0) return textPrompt(appended);
-	return [...prompt, ...textPrompt(appended)];
-}
-function promptToDisplayText(prompt) {
-	return prompt.map((block) => contentBlockDisplayText(block)).filter((entry) => entry.trim().length > 0).join("\n\n").trim();
-}
-function contentBlockDisplayText(block) {
-	switch (block.type) {
-		case "text": return block.text;
-		case "resource_link": return block.title ?? block.name ?? block.uri;
-		case "resource": return resourceBlockDisplayText(block);
-		case "image": return `[image] ${block.mimeType}`;
-		case "audio": return `[audio] ${block.mimeType}`;
-		default: return "";
-	}
-}
-function resourceBlockDisplayText(block) {
-	return "text" in block.resource && typeof block.resource.text === "string" ? block.resource.text : block.resource.uri;
-}
-//#endregion
 //#region src/process-identity.ts
 const IDENTITY_QUERY_TIMEOUT_MS$1 = 2e3;
 const LINUX_PROCESS_QUERY = `
@@ -2439,12 +2446,228 @@ 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;
+//#region src/session/lock-owner.ts
+const OBSERVATION_REUSE_MS = 1e3;
+const IDENTITY_QUERY_TIMEOUT_MS = 1e3;
+function lockOwnerPid(value) {
+	if (!value || typeof value !== "object" || !("pid" in value)) return;
+	const pid = value.pid;
+	return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function canReuseObservation(preserved, pid, identity, fresh) {
+	return !fresh && preserved?.pid === pid && compareProcessBirthIdentity(preserved.identity, identity) === "matching" && performance.now() - preserved.checkedAt < OBSERVATION_REUSE_MS;
+}
+async function createLockOwner(options = {}) {
+	const { signal, capturedIdentity } = options;
+	signal?.throwIfAborted();
+	const processIdentity = capturedIdentity === void 0 ? await getOwnProcessIdentity() : capturedIdentity.processIdentity;
+	signal?.throwIfAborted();
+	let preserved;
+	return {
+		payload: {
+			pid: process.pid,
+			processIdentity
+		},
+		async hasExited(payload, fresh, signal) {
+			signal?.throwIfAborted();
+			const pid = lockOwnerPid(payload);
+			if (!pid) return false;
+			const identity = parseProcessBirthIdentity(payload.processIdentity);
+			if (identity && canReuseObservation(preserved, pid, identity, fresh)) return false;
+			const incarnation = await observeProcessIncarnation(pid, identity, IDENTITY_QUERY_TIMEOUT_MS);
+			signal?.throwIfAborted();
+			if (identity && incarnation !== "gone") preserved = {
+				pid,
+				identity,
+				checkedAt: performance.now()
+			};
+			return incarnation === "gone";
+		}
+	};
+}
+//#endregion
+//#region src/prompt-content.ts
+var PromptInputValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "PromptInputValidationError";
+	}
+};
+function asRecord$1(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function isBase64Data(value) {
+	if (value.length === 0 || value.length % 4 !== 0) return false;
+	return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value);
+}
+function isImageMimeType(value) {
+	return /^image\/[A-Za-z0-9.+-]+$/i.test(value);
+}
+function isAudioMimeType(value) {
+	return /^audio\/[A-Za-z0-9.+-]+$/i.test(value);
+}
+function isTextBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "text" && typeof record.text === "string";
+}
+function isImageBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "image" && isNonEmptyString(record.mimeType) && isImageMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
+}
+function isAudioBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "audio" && isNonEmptyString(record.mimeType) && isAudioMimeType(record.mimeType) && typeof record.data === "string" && isBase64Data(record.data);
+}
+function isResourceLinkBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "resource_link" && isNonEmptyString(record.uri) && (record.title == null || typeof record.title === "string") && typeof record.name === "string";
+}
+function isResourcePayload(value) {
+	const record = asRecord$1(value);
+	if (!record || !isNonEmptyString(record.uri)) return false;
+	return typeof record.text === "string" || typeof record.blob === "string";
+}
+function isResourceBlock(value) {
+	const record = asRecord$1(value);
+	return record?.type === "resource" && isResourcePayload(record.resource);
+}
+const CONTENT_BLOCK_VALIDATORS = [
+	isTextBlock,
+	isImageBlock,
+	isAudioBlock,
+	isResourceLinkBlock,
+	isResourceBlock
+];
+function isContentBlock(value) {
+	return CONTENT_BLOCK_VALIDATORS.some((validator) => validator(value));
+}
+const CONTENT_BLOCK_ERROR_VALIDATORS = {
+	text: validateTextContentBlock,
+	image: validateImageContentBlock,
+	audio: validateAudioContentBlock,
+	resource_link: validateResourceLinkContentBlock,
+	resource: validateResourceContentBlock
+};
+function contentBlockErrorValidator(type) {
+	return Object.hasOwn(CONTENT_BLOCK_ERROR_VALIDATORS, type) ? CONTENT_BLOCK_ERROR_VALIDATORS[type] : void 0;
+}
+function validateTextContentBlock(record, index) {
+	return typeof record.text === "string" ? void 0 : `prompt[${index}] text block must include a string text field`;
+}
+function validateImageContentBlock(record, index) {
+	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] image block must include a non-empty mimeType`;
+	if (!isImageMimeType(record.mimeType)) return `prompt[${index}] image block mimeType must start with image/`;
+	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] image block must include non-empty base64 data`;
+	return isBase64Data(record.data) ? void 0 : `prompt[${index}] image block data must be valid base64`;
+}
+function validateAudioContentBlock(record, index) {
+	if (!isNonEmptyString(record.mimeType)) return `prompt[${index}] audio block must include a non-empty mimeType`;
+	if (!isAudioMimeType(record.mimeType)) return `prompt[${index}] audio block mimeType must start with audio/`;
+	if (typeof record.data !== "string" || record.data.length === 0) return `prompt[${index}] audio block must include non-empty base64 data`;
+	return isBase64Data(record.data) ? void 0 : `prompt[${index}] audio block data must be valid base64`;
+}
+function validateResourceLinkContentBlock(record, index) {
+	if (!isNonEmptyString(record.uri)) return `prompt[${index}] resource_link block must include a non-empty uri`;
+	if (record.title != null && typeof record.title !== "string") return `prompt[${index}] resource_link block title must be a string or null when present`;
+	if (typeof record.name !== "string") return `prompt[${index}] resource_link block must include a string name`;
+}
+function validateResourceContentBlock(record, index) {
+	if (!asRecord$1(record.resource)) return `prompt[${index}] resource block must include a resource object`;
+	return isResourcePayload(record.resource) ? void 0 : `prompt[${index}] resource block resource must include a non-empty uri and a string text or blob field`;
+}
+function getContentBlockValidationError(value, index) {
+	const record = asRecord$1(value);
+	if (!record || typeof record.type !== "string") return `prompt[${index}] must be an ACP content block object`;
+	const validator = contentBlockErrorValidator(record.type);
+	return validator ? validator(record, index) : `prompt[${index}] has unsupported content block type ${JSON.stringify(record.type)}`;
+}
+function isPromptInput(value) {
+	return Array.isArray(value) && value.every((entry) => isContentBlock(entry));
+}
+function promptCapabilityRequirement(block) {
+	switch (block.type) {
+		case "image": return {
+			blockType: "image",
+			capability: "image"
+		};
+		case "audio": return {
+			blockType: "audio",
+			capability: "audio"
+		};
+		case "resource": return {
+			blockType: "resource",
+			capability: "embeddedContext"
+		};
+		default: return;
+	}
+}
+function getUnsupportedPromptContentMessage(prompt, agentCapabilities) {
+	for (const [index, block] of prompt.entries()) {
+		const requirement = promptCapabilityRequirement(block);
+		if (!requirement) continue;
+		if (agentCapabilities?.promptCapabilities?.[requirement.capability] === true) continue;
+		return `prompt[${index}] ${requirement.blockType} content requires agentCapabilities.promptCapabilities.${requirement.capability}`;
+	}
+}
+function textPrompt(text) {
+	return [{
+		type: "text",
+		text
+	}];
+}
+function parseStructuredPrompt(source) {
+	if (!source.startsWith("[")) return;
+	try {
+		const parsed = JSON.parse(source);
+		if (isPromptInput(parsed)) return parsed;
+		if (Array.isArray(parsed)) throw new PromptInputValidationError(parsed.map((entry, index) => getContentBlockValidationError(entry, index)).find((message) => message !== void 0) ?? "Structured prompt JSON must be an array of valid ACP content blocks");
+		return;
+	} catch (error) {
+		if (error instanceof PromptInputValidationError) throw error;
+		return;
+	}
+}
+function parsePromptSource(source) {
+	const trimmed = source.trim();
+	const structured = parseStructuredPrompt(trimmed);
+	if (structured) return structured;
+	if (!trimmed) return [];
+	return textPrompt(trimmed);
+}
+function mergePromptSourceWithText(source, suffixText) {
+	const prompt = parsePromptSource(source);
+	const appended = suffixText.trim();
+	if (!appended) return prompt;
+	if (prompt.length === 0) return textPrompt(appended);
+	return [...prompt, ...textPrompt(appended)];
+}
+function promptToDisplayText(prompt) {
+	return prompt.map((block) => contentBlockDisplayText(block)).filter((entry) => entry.trim().length > 0).join("\n\n").trim();
+}
+function contentBlockDisplayText(block) {
+	switch (block.type) {
+		case "text": return block.text;
+		case "resource_link": return block.title ?? block.name ?? block.uri;
+		case "resource": return resourceBlockDisplayText(block);
+		case "image": return `[image] ${block.mimeType}`;
+		case "audio": return `[audio] ${block.mimeType}`;
+		default: return "";
+	}
+}
+function resourceBlockDisplayText(block) {
+	return "text" in block.resource && typeof block.resource.text === "string" ? block.resource.text : block.resource.uri;
+}
+//#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()) {
@@ -2463,6 +2686,8 @@ var ProcessDescendants = class {
 	rootBirth;
 	pending;
 	retired = false;
+	failedRootObservation = false;
+	unresolvedOwnership = false;
 	ownProcessGroup;
 	captureGroupAfterExit;
 	groupExitedAt;
@@ -2497,10 +2722,18 @@ var ProcessDescendants = class {
 			}
 			return true;
 		} catch {
-			if (!isChildProcessRunning(this.child)) this.captureGroupAfterExit = false;
+			this.recordSnapshotFailure(captureRootGroup);
 			return false;
 		}
 	}
+	recordSnapshotFailure(captureRootGroup) {
+		if (isChildProcessRunning(this.child)) {
+			this.failedRootObservation = true;
+			return;
+		}
+		if (captureRootGroup) this.unresolvedOwnership = true;
+		this.captureGroupAfterExit = false;
+	}
 	requiredSnapshotPids(rootWasRunning) {
 		return [...this.identities.keys(), ...rootWasRunning && this.child.pid ? [this.child.pid] : []];
 	}
@@ -2512,6 +2745,10 @@ var ProcessDescendants = class {
 			if (observed && compareProcessBirthIdentity(identity.birth, observed.birth) === "matching") owned.add(pid);
 		}
 		this.includeRoot(table, owned);
+		if (owned.has(this.child.pid ?? 0)) {
+			this.failedRootObservation = false;
+			this.unresolvedOwnership = false;
+		}
 		if (this.ownProcessGroup) this.includeProcessGroup(table, owned, rootWasRunning);
 		includeProcessDescendants(table, owned);
 		owned.delete(this.child.pid ?? 0);
@@ -2532,29 +2769,40 @@ var ProcessDescendants = class {
 	}
 	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);
+		if (!root || !(rootWasRunning || [...owned].some((pid) => table.get(pid)?.groupPid === root))) return;
+		this.unresolvedOwnership = !this.admitGroupMembers(table, owned, root);
+		if (!this.unresolvedOwnership) this.failedRootObservation = false;
+	}
+	admitGroupMembers(table, owned, groupPid) {
+		let verified = true;
+		for (const identity of table.values()) {
+			if (identity.groupPid !== groupPid) continue;
+			const beforeExit = this.startedBeforeRootExit(identity);
+			if (beforeExit === void 0) verified = false;
+			else if (beforeExit) owned.add(identity.pid);
 		}
+		return verified;
 	}
 	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;
+		if (cutoff === null) return;
+		if (identity.birth.kind !== "linux-proc") return typeof cutoff === "number" ? Date.parse(identity.birth.value) <= cutoff : void 0;
+		if (typeof cutoff === "number" || identity.birth.timeNamespace !== cutoff.timeNamespace || !identity.clockTicksPerSecond) return;
 		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);
-		}
+		} catch {}
 	}
 	hasTrackedProcesses() {
 		return this.identities.size > 0;
 	}
+	hasUnresolvedOwnership() {
+		return this.unresolvedOwnership || !this.ownProcessGroup && this.failedRootObservation && !isChildProcessRunning(this.child);
+	}
 	async waitForExit(timeoutMs) {
 		const deadline = performance.now() + timeoutMs;
 		do {
@@ -2571,46 +2819,6 @@ var ProcessDescendants = class {
 	}
 };
 //#endregion
-//#region src/session/lock-owner.ts
-const OBSERVATION_REUSE_MS = 1e3;
-const IDENTITY_QUERY_TIMEOUT_MS = 1e3;
-function lockOwnerPid(value) {
-	if (!value || typeof value !== "object" || !("pid" in value)) return;
-	const pid = value.pid;
-	return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
-}
-function canReuseObservation(preserved, pid, identity, fresh) {
-	return !fresh && preserved?.pid === pid && compareProcessBirthIdentity(preserved.identity, identity) === "matching" && performance.now() - preserved.checkedAt < OBSERVATION_REUSE_MS;
-}
-async function createLockOwner(options = {}) {
-	const { signal, capturedIdentity } = options;
-	signal?.throwIfAborted();
-	const processIdentity = capturedIdentity === void 0 ? await getOwnProcessIdentity() : capturedIdentity.processIdentity;
-	signal?.throwIfAborted();
-	let preserved;
-	return {
-		payload: {
-			pid: process.pid,
-			processIdentity
-		},
-		async hasExited(payload, fresh, signal) {
-			signal?.throwIfAborted();
-			const pid = lockOwnerPid(payload);
-			if (!pid) return false;
-			const identity = parseProcessBirthIdentity(payload.processIdentity);
-			if (identity && canReuseObservation(preserved, pid, identity, fresh)) return false;
-			const incarnation = await observeProcessIncarnation(pid, identity, IDENTITY_QUERY_TIMEOUT_MS);
-			signal?.throwIfAborted();
-			if (identity && incarnation !== "gone") preserved = {
-				pid,
-				identity,
-				checkedAt: performance.now()
-			};
-			return incarnation === "gone";
-		}
-	};
-}
-//#endregion
 //#region src/session/queue/paths.ts
 function shortHash(value, length) {
 	return createHash("sha256").update(value).digest("hex").slice(0, length);
@@ -2697,16 +2905,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 +2938,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 +2974,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 +3481,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 +3519,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 +3542,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 +3631,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) => {
@@ -3815,7 +4087,7 @@ function parseStringResultOwnerMessage(message, context, type, field) {
 function parseSetModelOwnerMessage(message, context) {
 	if (typeof message.modelId !== "string") return null;
 	const response = asRecord(message.response);
-	if (message.response !== void 0 && (!response || !Array.isArray(response.configOptions))) return null;
+	if (message.response !== void 0 && (!response || response.configOptions !== void 0 && !Array.isArray(response.configOptions))) return null;
 	return {
 		type: "set_model_result",
 		...context,
@@ -3825,7 +4097,7 @@ function parseSetModelOwnerMessage(message, context) {
 }
 function parseSetConfigOptionOwnerMessage(message, context) {
 	const response = asRecord(message.response);
-	if (!response || !Array.isArray(response.configOptions)) return null;
+	if (!response || response.configOptions !== void 0 && !Array.isArray(response.configOptions)) return null;
 	return {
 		type: "set_config_option_result",
 		...context,
@@ -3870,8 +4142,611 @@ 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) {
 	if (owner.ownerGeneration !== void 0 && message.ownerGeneration !== void 0 && message.ownerGeneration !== owner.ownerGeneration) throw new QueueProtocolError("Queue owner returned mismatched generation", {
 		detailCode: "QUEUE_OWNER_GENERATION_MISMATCH",
@@ -3957,7 +4832,7 @@ async function runQueueOwnerRequest(options) {
 	socket.setEncoding("utf8");
 	return await new Promise((resolve, reject) => {
 		let settled = false;
-		let buffer = "";
+		const responseFragments = [];
 		const state = { acknowledged: false };
 		const finishResolve = (result) => {
 			if (settled) return;
@@ -4001,19 +4876,21 @@ async function runQueueOwnerRequest(options) {
 			}
 		};
 		socket.on("data", (chunk) => {
-			buffer += chunk;
-			if (buffer.length > 10485760) {
-				socket.destroy();
-				finishReject(uncertainQueueOutcome(/* @__PURE__ */ new Error(`Message buffer exceeded ${MAX_MESSAGE_BUFFER_SIZE} bytes`)));
-				return;
-			}
-			let index = buffer.indexOf("\n");
-			while (index >= 0) {
-				if (settled) return;
-				const line = buffer.slice(0, index).trim();
-				buffer = buffer.slice(index + 1);
-				if (line.length > 0) processLine(line);
-				index = buffer.indexOf("\n");
+			try {
+				let offset = 0;
+				let newline = chunk.indexOf("\n");
+				while (newline >= 0) {
+					if (settled) return;
+					responseFragments.push(chunk.slice(offset, newline));
+					const line = responseFragments.join("").trim();
+					responseFragments.length = 0;
+					if (line.length > 0) processLine(line);
+					offset = newline + 1;
+					newline = chunk.indexOf("\n", offset);
+				}
+				if (!settled && offset < chunk.length) responseFragments.push(chunk.slice(offset));
+			} catch (error) {
+				finishReject(uncertainQueueOutcome(error));
 			}
 		});
 		socket.once("error", (error) => {
@@ -4340,6 +5217,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_MODES as At, assertPersistedKeyPolicy as B, GeminiAcpStartupTimeoutError as Bt, textPrompt as C, normalizeOutputError as Ct, DEFAULT_HISTORY_LIMIT as D, EXIT_CODES as Dt, observeProcessIncarnation as E, AUTH_POLICIES as Et, normalizeName as F, AgentSpawnError as Ft, SESSION_JOURNAL_SCHEMA as G, SessionModeReplayError as Gt, serializeSessionRecordForDisk as H, PermissionPromptUnavailableError as Ht, pruneSessions as I, AgentStartupError as It, watchSession as J, SessionResumeRequiredError as Jt, SessionJournalReader as K, SessionModelReplayError as Kt, readSessionRecord as L, AuthPolicyError as Lt, isoNow as M, SESSION_RECORD_SCHEMA as Mt, listSessions as N, AcpxOperationalError as Nt, absolutePath as O, NON_INTERACTIVE_PERMISSION_POLICIES as Ot, listSessionsForAgent as P, AgentDisconnectedError as Pt, measurePerf as Q, resolveSessionRecord as R, ClaudeAcpSessionCreateTimeoutError as Rt, promptToDisplayText as S, isRetryablePromptError as St, lockOwnerPid as T, isAcpResourceNotFoundError as Tt, extractAgentSessionId as U, QueueConnectionError as Ut, parseSessionRecord as V, PermissionDeniedError as Vt, normalizeAgentSessionId as W, SessionConfigOptionReplayError as Wt, getPerfMetricsSnapshot as X, formatPerfMetric as Y, UnsupportedPromptContentError as Yt, incrementPerfCounter as Z, ProcessDescendants as _, _usingCtx as _t, trySetModelOnRunningOwner as a, isSessionUpdateNotification as at, mergePromptSourceWithText as b, formatErrorMessage 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, PERMISSION_POLICY_ACTIONS as jt, findGitRepositoryRoot as k, OUTPUT_FORMATS 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, SessionNotFoundError 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, PromptInputValidationError as v, isProcessAlive as vt, createLockOwner as w, extractAcpError as wt, parsePromptSource as x, isAcpQueryClosedBeforeResponseError as xt, getUnsupportedPromptContentMessage as y, exitCodeForOutputErrorCode as yt, writeSessionRecord as z, CopilotAcpUnsupportedError as zt };
 
-//# sourceMappingURL=ipc-DAApJ5mi.js.map
+//# sourceMappingURL=ipc-BW06Pbb8.js.map