acpx 0.8.0 → 0.9.0

package/dist/{output-BL9XRWzS.js → output-DPg20dvn.js}

@@ -1,4 +1,4 @@
-import { $ as getPerfMetricsSnapshot, A as parsePromptStopReason, B as normalizeName, C as mergeSessionOptions, Ct as formatErrorMessage, D as extractSessionUpdateNotification, E as AcpClient, F as findSession, H as resolveSessionRecord, I as findSessionByDirectoryWalk, J as sessionEventActivePath, K as defaultSessionEventLog, L as isoNow, Mt as OUTPUT_ERROR_CODES, N as absolutePath, Nt as OUTPUT_ERROR_ORIGINS, O as isAcpJsonRpcMessage, Ot as toAcpErrorPayload, P as findGitRepositoryRoot, Q as formatPerfMetric, R as listSessions, Rt as QueueConnectionError, S as trimConversationForRuntime, T as sessionOptionsFromRecord, Tt as normalizeOutputError, U as writeSessionRecord, V as pruneSessions, X as sessionEventSegmentPath, Y as sessionEventLockPath, _ as cloneSessionConversation, _t as withTimeout, a as applyConversation, at as startPerfTimer, b as recordPromptSubmission, c as applyRequestedModelIfAdvertised, d as setDesiredConfigOption, et as incrementPerfCounter, f as setDesiredModeId, ft as promptToDisplayText, g as cloneSessionAcpxState, gt as withInterrupt, h as applyConfigOptionsToRecord, ht as TimeoutError, i as connectAndLoadSession, it as setPerfGauge, k as parseJsonRpcErrorMessage, l as assertRequestedModelSupported, lt as isPromptInput, m as syncAdvertisedModelState, mt as InterruptedError, n as runPromptTurn, nt as recordPerfDuration, o as applyLifecycleSnapshotToRecord, p as setDesiredModelId, pt as textPrompt, q as sessionBaseDir, r as withConnectedSession, rt as resetPerfMetrics, st as normalizeRuntimeSessionId, t as LiveSessionCheckpoint, tt as measurePerf, u as setCurrentModelId, v as createSessionConversation, w as persistSessionOptions, wt as isRetryablePromptError, x as recordSessionUpdate, y as recordClientOperation, z as listSessionsForAgent, zt as QueueProtocolError } from "./live-checkpoint-B9ctAuqV.js";
+import { $ as getPerfMetricsSnapshot, A as parsePromptStopReason, B as normalizeName, Bt as QueueProtocolError, C as applyConversation, Ct as formatErrorMessage, D as extractSessionUpdateNotification, E as AcpClient, F as findSession, H as resolveSessionRecord, I as findSessionByDirectoryWalk, J as sessionEventActivePath, K as defaultSessionEventLog, L as isoNow, Mt as OUTPUT_ERROR_CODES, N as absolutePath, Nt as OUTPUT_ERROR_ORIGINS, O as isAcpJsonRpcMessage, Ot as toAcpErrorPayload, P as findGitRepositoryRoot, Q as formatPerfMetric, R as listSessions, S as sessionOptionsFromRecord, Tt as normalizeOutputError, U as writeSessionRecord, V as pruneSessions, X as sessionEventSegmentPath, Y as sessionEventLockPath, _ as recordPromptSubmission, _t as withTimeout, a as applyRequestedModelIfAdvertised, at as startPerfTimer, b as mergeSessionOptions, c as setDesiredConfigOption, d as syncAdvertisedModelState, et as incrementPerfCounter, f as applyConfigOptionsToRecord, ft as promptToDisplayText, g as recordClientOperation, gt as withInterrupt, h as createSessionConversation, ht as TimeoutError, i as connectAndLoadSession, it as setPerfGauge, k as parseJsonRpcErrorMessage, l as setDesiredModeId, lt as isPromptInput, m as cloneSessionConversation, mt as InterruptedError, n as runPromptTurn, nt as recordPerfDuration, o as assertRequestedModelSupported, p as cloneSessionAcpxState, pt as textPrompt, q as sessionBaseDir, r as withConnectedSession, rt as resetPerfMetrics, s as setCurrentModelId, st as normalizeRuntimeSessionId, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModelId, v as recordSessionUpdate, w as applyLifecycleSnapshotToRecord, wt as isRetryablePromptError, x as persistSessionOptions, y as trimConversationForRuntime, z as listSessionsForAgent, zt as QueueConnectionError } from "./live-checkpoint-D5d-K9s1.js";
 import fs, { realpathSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -26,6 +26,17 @@ function normalizeQueueOwnerTtlMs(ttlMs) {
 	return Math.round(ttlMs);
 }
 //#endregion
+//#region src/process-liveness.ts
+function isProcessAlive(pid) {
+	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
 //#region src/cli/queue/paths.ts
 function shortHash(value, length) {
 	return createHash("sha256").update(value).digest("hex").slice(0, length);
@@ -56,7 +67,7 @@ const QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
 function parseQueueOwnerRecord(raw) {
 	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
 	const record = raw;
-	if (!Number.isInteger(record.pid) || record.pid <= 0 || typeof record.sessionId !== "string" || typeof record.socketPath !== "string" || typeof record.createdAt !== "string" || typeof record.heartbeatAt !== "string" || !Number.isInteger(record.ownerGeneration) || record.ownerGeneration <= 0 || !Number.isInteger(record.queueDepth) || record.queueDepth < 0) return null;
+	if (!hasValidQueueOwnerRecordFields(record)) return null;
 	return {
 		pid: record.pid,
 		sessionId: record.sessionId,
@@ -67,6 +78,15 @@ function parseQueueOwnerRecord(raw) {
 		queueDepth: record.queueDepth
 	};
 }
+function hasValidQueueOwnerRecordFields(record) {
+	return isPositiveInteger(record.pid) && typeof record.sessionId === "string" && typeof record.socketPath === "string" && typeof record.createdAt === "string" && typeof record.heartbeatAt === "string" && isPositiveInteger(record.ownerGeneration) && isNonNegativeInteger(record.queueDepth);
+}
+function isPositiveInteger(value) {
+	return Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+	return Number.isInteger(value) && value >= 0;
+}
 function createOwnerGeneration() {
 	return randomInt(1, 2 ** 48);
 }
@@ -126,15 +146,6 @@ async function readQueueOwnerRecord(sessionId) {
 		return;
 	}
 }
-function isProcessAlive(pid) {
-	if (!pid || !Number.isInteger(pid) || pid <= 0 || pid === process.pid) return false;
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
 async function terminateProcess(pid) {
 	if (!isProcessAlive(pid)) return false;
 	try {
@@ -351,18 +362,22 @@ function isNonInteractivePermissionPolicy(value) {
 	return value === "deny" || value === "fail";
 }
 function isPermissionPolicy(value) {
-	if (value == null) return false;
-	if (typeof value !== "object" || Array.isArray(value)) return false;
-	const record = value;
+	const record = asRecord$2(value);
+	if (!record) return false;
+	return hasValidPermissionRuleLists(record) && hasValidPermissionDefaultAction(record);
+}
+function hasValidPermissionRuleLists(record) {
 	for (const key of [
 		"autoApprove",
 		"autoDeny",
 		"escalate"
-	]) {
-		const entry = record[key];
-		if (entry == null) continue;
-		if (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")) return false;
-	}
+	]) if (!isOptionalStringList(record[key])) return false;
+	return true;
+}
+function isOptionalStringList(value) {
+	return value == null || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasValidPermissionDefaultAction(record) {
 	return record.defaultAction == null || record.defaultAction === "approve" || record.defaultAction === "deny" || record.defaultAction === "escalate";
 }
 function isOutputErrorCode(value) {
@@ -373,35 +388,58 @@ function isOutputErrorOrigin(value) {
 }
 function isPermissionEscalationEvent(value) {
 	const event = asRecord$2(value);
-	return event?.type === "permission_escalation" && typeof event.sessionId === "string" && typeof event.toolCallId === "string" && typeof event.toolTitle === "string" && event.action === "escalate" && typeof event.message === "string" && typeof event.timestamp === "string" && (event.toolName == null || typeof event.toolName === "string") && (event.toolKind == null || typeof event.toolKind === "string") && (event.matchedRule == null || typeof event.matchedRule === "string");
+	return !!event && hasRequiredPermissionEscalationFields(event) && hasOptionalStringFields(event, [
+		"toolName",
+		"toolKind",
+		"matchedRule"
+	]);
+}
+function hasRequiredPermissionEscalationFields(event) {
+	return event.type === "permission_escalation" && typeof event.sessionId === "string" && typeof event.toolCallId === "string" && typeof event.toolTitle === "string" && event.action === "escalate" && typeof event.message === "string" && typeof event.timestamp === "string";
+}
+function hasOptionalStringFields(record, keys) {
+	return keys.every((key) => record[key] == null || typeof record[key] === "string");
 }
 function parseSessionOptions(value) {
 	if (value == null) return;
 	const record = asRecord$2(value);
 	if (!record) return null;
 	const sessionOptions = {};
-	if (record.model != null) {
-		if (typeof record.model !== "string" || record.model.trim().length === 0) return null;
-		sessionOptions.model = record.model;
-	}
-	if (record.allowedTools != null) {
-		if (!Array.isArray(record.allowedTools)) return null;
-		const allowedTools = record.allowedTools.filter((tool) => typeof tool === "string");
-		if (allowedTools.length !== record.allowedTools.length) return null;
-		sessionOptions.allowedTools = allowedTools;
-	}
-	if (record.maxTurns != null) {
-		if (typeof record.maxTurns !== "number" || !Number.isFinite(record.maxTurns)) return null;
-		sessionOptions.maxTurns = Math.max(1, Math.round(record.maxTurns));
-	}
-	if (record.systemPrompt != null) if (typeof record.systemPrompt === "string") sessionOptions.systemPrompt = record.systemPrompt;
-	else {
-		const systemPrompt = asRecord$2(record.systemPrompt);
-		if (!systemPrompt || typeof systemPrompt.append !== "string") return null;
-		sessionOptions.systemPrompt = { append: systemPrompt.append };
-	}
+	if (!assignSessionModel(sessionOptions, record.model)) return null;
+	if (!assignSessionAllowedTools(sessionOptions, record.allowedTools)) return null;
+	if (!assignSessionMaxTurns(sessionOptions, record.maxTurns)) return null;
+	if (!assignSessionSystemPrompt(sessionOptions, record.systemPrompt)) return null;
 	return sessionOptions;
 }
+function assignSessionModel(options, value) {
+	if (value == null) return true;
+	if (typeof value !== "string" || value.trim().length === 0) return false;
+	options.model = value;
+	return true;
+}
+function assignSessionAllowedTools(options, value) {
+	if (value == null) return true;
+	if (!Array.isArray(value) || value.some((tool) => typeof tool !== "string")) return false;
+	options.allowedTools = value;
+	return true;
+}
+function assignSessionMaxTurns(options, value) {
+	if (value == null) return true;
+	if (typeof value !== "number" || !Number.isFinite(value)) return false;
+	options.maxTurns = Math.max(1, Math.round(value));
+	return true;
+}
+function assignSessionSystemPrompt(options, value) {
+	if (value == null) return true;
+	if (typeof value === "string") {
+		options.systemPrompt = value;
+		return true;
+	}
+	const systemPrompt = asRecord$2(value);
+	if (!systemPrompt || typeof systemPrompt.append !== "string") return false;
+	options.systemPrompt = { append: systemPrompt.append };
+	return true;
+}
 function parseOwnerGeneration(value) {
 	if (value == null) return;
 	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) return null;
@@ -414,189 +452,245 @@ function parseNonNegativeInteger(value) {
 }
 function parseQueueRequest(raw) {
 	const request = asRecord$2(raw);
-	if (!request) return null;
-	if (typeof request.type !== "string" || typeof request.requestId !== "string") return null;
+	if (!request || typeof request.type !== "string" || typeof request.requestId !== "string") return null;
 	const ownerGeneration = parseOwnerGeneration(request.ownerGeneration);
 	if (ownerGeneration === null) return null;
-	const timeoutRaw = request.timeoutMs;
-	const timeoutMs = typeof timeoutRaw === "number" && Number.isFinite(timeoutRaw) && timeoutRaw > 0 ? Math.round(timeoutRaw) : void 0;
-	if (request.type === "submit_prompt") {
-		const resumePolicy = request.resumePolicy == null ? void 0 : isSessionResumePolicy(request.resumePolicy) ? request.resumePolicy : null;
-		const nonInteractivePermissions = request.nonInteractivePermissions == null ? void 0 : isNonInteractivePermissionPolicy(request.nonInteractivePermissions) ? request.nonInteractivePermissions : null;
-		const permissionPolicy = request.permissionPolicy == null ? void 0 : isPermissionPolicy(request.permissionPolicy) ? request.permissionPolicy : null;
-		const suppressSdkConsoleErrors = request.suppressSdkConsoleErrors == null ? void 0 : typeof request.suppressSdkConsoleErrors === "boolean" ? request.suppressSdkConsoleErrors : null;
-		const promptRetries = parseNonNegativeInteger(request.promptRetries);
-		const sessionOptions = parseSessionOptions(request.sessionOptions);
-		const prompt = request.prompt == null ? void 0 : isPromptInput(request.prompt) ? request.prompt : null;
-		if (typeof request.message !== "string" || !isPermissionMode(request.permissionMode) || resumePolicy === null || prompt === null || nonInteractivePermissions === null || permissionPolicy === null || suppressSdkConsoleErrors === null || promptRetries === null || sessionOptions === null || typeof request.waitForCompletion !== "boolean") return null;
-		return {
-			type: "submit_prompt",
-			requestId: request.requestId,
-			ownerGeneration,
-			message: request.message,
-			prompt: prompt ?? textPrompt(request.message),
-			permissionMode: request.permissionMode,
-			...resumePolicy !== void 0 ? { resumePolicy } : {},
-			nonInteractivePermissions,
-			...permissionPolicy !== void 0 ? { permissionPolicy } : {},
-			timeoutMs,
-			...suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors } : {},
-			...promptRetries !== void 0 ? { promptRetries } : {},
-			waitForCompletion: request.waitForCompletion,
-			...sessionOptions !== void 0 ? { sessionOptions } : {}
-		};
-	}
-	if (request.type === "cancel_prompt") return {
-		type: "cancel_prompt",
-		requestId: request.requestId,
-		ownerGeneration
-	};
-	if (request.type === "close_session") return {
-		type: "close_session",
-		requestId: request.requestId,
+	return parseTypedQueueRequest(request, parseQueueRequestContext(request.requestId, ownerGeneration, request.timeoutMs));
+}
+function parseQueueRequestContext(requestId, ownerGeneration, timeoutRaw) {
+	return {
+		requestId,
 		ownerGeneration,
-		timeoutMs
+		timeoutMs: parsePositiveTimeout(timeoutRaw)
 	};
-	if (request.type === "set_mode") {
-		if (typeof request.modeId !== "string" || request.modeId.trim().length === 0) return null;
-		return {
-			type: "set_mode",
-			requestId: request.requestId,
-			ownerGeneration,
-			modeId: request.modeId,
-			timeoutMs
-		};
-	}
-	if (request.type === "set_model") {
-		if (typeof request.modelId !== "string" || request.modelId.trim().length === 0) return null;
-		return {
-			type: "set_model",
-			requestId: request.requestId,
-			ownerGeneration,
-			modelId: request.modelId,
-			timeoutMs
+}
+function parsePositiveTimeout(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
+	return Math.round(value);
+}
+function parseTypedQueueRequest(request, context) {
+	switch (request.type) {
+		case "submit_prompt": return parseSubmitRequest(request, context);
+		case "cancel_prompt": return {
+			type: "cancel_prompt",
+			requestId: context.requestId,
+			ownerGeneration: context.ownerGeneration
 		};
-	}
-	if (request.type === "set_config_option") {
-		if (typeof request.configId !== "string" || request.configId.trim().length === 0 || typeof request.value !== "string" || request.value.trim().length === 0) return null;
-		return {
-			type: "set_config_option",
-			requestId: request.requestId,
-			ownerGeneration,
-			configId: request.configId,
-			value: request.value,
-			timeoutMs
+		case "close_session": return {
+			type: "close_session",
+			...context
 		};
+		case "set_mode": return parseStringFieldRequest(request, context, "set_mode", "modeId");
+		case "set_model": return parseStringFieldRequest(request, context, "set_model", "modelId");
+		case "set_config_option": return parseSetConfigOptionRequest(request, context);
+		default: return null;
 	}
-	return null;
+}
+function parseSubmitRequest(request, context) {
+	const parsed = parseSubmitRequestFields(request);
+	if (!parsed) return null;
+	return {
+		type: "submit_prompt",
+		requestId: context.requestId,
+		ownerGeneration: context.ownerGeneration,
+		message: parsed.message,
+		prompt: parsed.prompt ?? textPrompt(parsed.message),
+		permissionMode: parsed.permissionMode,
+		...parsed.resumePolicy !== void 0 ? { resumePolicy: parsed.resumePolicy } : {},
+		nonInteractivePermissions: parsed.nonInteractivePermissions,
+		...parsed.permissionPolicy !== void 0 ? { permissionPolicy: parsed.permissionPolicy } : {},
+		timeoutMs: context.timeoutMs,
+		...parsed.suppressSdkConsoleErrors !== void 0 ? { suppressSdkConsoleErrors: parsed.suppressSdkConsoleErrors } : {},
+		...parsed.promptRetries !== void 0 ? { promptRetries: parsed.promptRetries } : {},
+		waitForCompletion: parsed.waitForCompletion,
+		...parsed.sessionOptions !== void 0 ? { sessionOptions: parsed.sessionOptions } : {}
+	};
+}
+function parseSubmitRequestFields(request) {
+	const parsed = {
+		message: typeof request.message === "string" ? request.message : null,
+		prompt: parseOptionalValue(request.prompt, isPromptInput),
+		permissionMode: parseRequiredValue(request.permissionMode, isPermissionMode),
+		resumePolicy: parseOptionalValue(request.resumePolicy, isSessionResumePolicy),
+		nonInteractivePermissions: parseOptionalValue(request.nonInteractivePermissions, isNonInteractivePermissionPolicy),
+		permissionPolicy: parseOptionalValue(request.permissionPolicy, isPermissionPolicy),
+		suppressSdkConsoleErrors: parseOptionalBoolean(request.suppressSdkConsoleErrors),
+		promptRetries: parseNonNegativeInteger(request.promptRetries),
+		waitForCompletion: typeof request.waitForCompletion === "boolean" ? request.waitForCompletion : null,
+		sessionOptions: parseSessionOptions(request.sessionOptions)
+	};
+	if (Object.values(parsed).some((value) => value === null)) return null;
+	return parsed;
+}
+function parseOptionalValue(value, guard) {
+	if (value == null) return;
+	return guard(value) ? value : null;
+}
+function parseRequiredValue(value, guard) {
+	return guard(value) ? value : null;
+}
+function parseOptionalBoolean(value) {
+	if (value == null) return;
+	return typeof value === "boolean" ? value : null;
+}
+function parseStringFieldRequest(request, context, type, field) {
+	const value = parseNonEmptyString(request[field]);
+	if (!value) return null;
+	return {
+		type,
+		...context,
+		[field]: value
+	};
+}
+function parseSetConfigOptionRequest(request, context) {
+	const configId = parseNonEmptyString(request.configId);
+	const value = parseNonEmptyString(request.value);
+	if (!configId || !value) return null;
+	return {
+		type: "set_config_option",
+		...context,
+		configId,
+		value
+	};
+}
+function parseNonEmptyString(value) {
+	if (typeof value !== "string" || value.trim().length === 0) return null;
+	return value;
 }
 function parseSessionSendResult(raw) {
 	const result = asRecord$2(raw);
-	if (!result) return null;
-	if (typeof result.stopReason !== "string" || typeof result.sessionId !== "string" || typeof result.resumed !== "boolean") return null;
+	if (!result || !hasValidSessionSendResultCore(result)) return null;
 	const permissionStats = asRecord$2(result.permissionStats);
 	const record = asRecord$2(result.record);
 	if (!permissionStats || !record) return null;
-	if (!(typeof permissionStats.requested === "number" && typeof permissionStats.approved === "number" && typeof permissionStats.denied === "number" && typeof permissionStats.cancelled === "number")) return null;
-	if (!(typeof record.acpxRecordId === "string" && typeof record.acpSessionId === "string" && typeof record.agentCommand === "string" && typeof record.cwd === "string" && typeof record.createdAt === "string" && typeof record.lastUsedAt === "string" && Array.isArray(record.messages) && typeof record.updated_at === "string" && typeof record.lastSeq === "number" && Number.isInteger(record.lastSeq) && !!record.eventLog && typeof record.eventLog === "object")) return null;
+	if (!hasValidPermissionStats(permissionStats)) return null;
+	if (!hasValidSessionRecordShape(record)) return null;
 	return result;
 }
+function hasValidSessionSendResultCore(result) {
+	return typeof result.stopReason === "string" && typeof result.sessionId === "string" && typeof result.resumed === "boolean";
+}
+function hasValidPermissionStats(permissionStats) {
+	return [
+		"requested",
+		"approved",
+		"denied",
+		"cancelled"
+	].every((key) => typeof permissionStats[key] === "number");
+}
+function hasValidSessionRecordShape(record) {
+	return hasStringFields(record, [
+		"acpxRecordId",
+		"acpSessionId",
+		"agentCommand",
+		"cwd",
+		"createdAt",
+		"lastUsedAt",
+		"updated_at"
+	]) && Array.isArray(record.messages) && typeof record.lastSeq === "number" && Number.isInteger(record.lastSeq) && !!record.eventLog && typeof record.eventLog === "object";
+}
+function hasStringFields(record, keys) {
+	return keys.every((key) => typeof record[key] === "string");
+}
 function parseQueueOwnerMessage(raw) {
 	const message = asRecord$2(raw);
-	if (!message || typeof message.type !== "string") return null;
-	if (typeof message.requestId !== "string") return null;
+	if (!message || typeof message.type !== "string" || typeof message.requestId !== "string") return null;
 	const ownerGeneration = parseOwnerGeneration(message.ownerGeneration);
 	if (ownerGeneration === null) return null;
-	if (message.type === "accepted") return {
-		type: "accepted",
+	return parseTypedQueueOwnerMessage(message, {
 		requestId: message.requestId,
 		ownerGeneration
+	});
+}
+function parseTypedQueueOwnerMessage(message, context) {
+	const parser = queueOwnerMessageParser(message.type);
+	return parser ? parser(message, context) : null;
+}
+const QUEUE_OWNER_MESSAGE_PARSERS = {
+	accepted: (_message, context) => ({
+		type: "accepted",
+		...context
+	}),
+	event: parseEventOwnerMessage,
+	permission_escalation: parsePermissionEscalationOwnerMessage,
+	result: parseResultOwnerMessage,
+	cancel_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "cancel_result", "cancelled"),
+	close_session_result: (message, context) => parseBooleanResultOwnerMessage(message, context, "close_session_result", "closed"),
+	set_mode_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_mode_result", "modeId"),
+	set_model_result: (message, context) => parseStringResultOwnerMessage(message, context, "set_model_result", "modelId"),
+	set_config_option_result: parseSetConfigOptionOwnerMessage,
+	error: parseErrorOwnerMessage
+};
+function queueOwnerMessageParser(type) {
+	return Object.hasOwn(QUEUE_OWNER_MESSAGE_PARSERS, type) ? QUEUE_OWNER_MESSAGE_PARSERS[type] : void 0;
+}
+function parseEventOwnerMessage(message, context) {
+	if (!isAcpJsonRpcMessage(message.message)) return null;
+	return {
+		type: "event",
+		...context,
+		message: message.message
 	};
-	if (message.type === "event") {
-		if (!isAcpJsonRpcMessage(message.message)) return null;
-		return {
-			type: "event",
-			requestId: message.requestId,
-			ownerGeneration,
-			message: message.message
-		};
-	}
-	if (message.type === "permission_escalation") {
-		if (!isPermissionEscalationEvent(message.event)) return null;
-		return {
-			type: "permission_escalation",
-			requestId: message.requestId,
-			ownerGeneration,
-			event: message.event
-		};
-	}
-	if (message.type === "result") {
-		const parsedResult = parseSessionSendResult(message.result);
-		if (!parsedResult) return null;
-		return {
-			type: "result",
-			requestId: message.requestId,
-			ownerGeneration,
-			result: parsedResult
-		};
-	}
-	if (message.type === "cancel_result") {
-		if (typeof message.cancelled !== "boolean") return null;
-		return {
-			type: "cancel_result",
-			requestId: message.requestId,
-			ownerGeneration,
-			cancelled: message.cancelled
-		};
-	}
-	if (message.type === "set_mode_result") {
-		if (typeof message.modeId !== "string") return null;
-		return {
-			type: "set_mode_result",
-			requestId: message.requestId,
-			ownerGeneration,
-			modeId: message.modeId
-		};
-	}
-	if (message.type === "set_model_result") {
-		if (typeof message.modelId !== "string") return null;
-		return {
-			type: "set_model_result",
-			requestId: message.requestId,
-			ownerGeneration,
-			modelId: message.modelId
-		};
-	}
-	if (message.type === "set_config_option_result") {
-		const response = asRecord$2(message.response);
-		if (!response || !Array.isArray(response.configOptions)) return null;
-		return {
-			type: "set_config_option_result",
-			requestId: message.requestId,
-			ownerGeneration,
-			response
-		};
-	}
-	if (message.type === "error") {
-		if (typeof message.message !== "string" || !isOutputErrorCode(message.code) || !isOutputErrorOrigin(message.origin)) return null;
-		const detailCode = typeof message.detailCode === "string" && message.detailCode.trim().length > 0 ? message.detailCode : void 0;
-		const retryable = typeof message.retryable === "boolean" ? message.retryable : void 0;
-		const acp = toAcpErrorPayload(message.acp);
-		const outputAlreadyEmitted = typeof message.outputAlreadyEmitted === "boolean" ? message.outputAlreadyEmitted : void 0;
-		return {
-			type: "error",
-			requestId: message.requestId,
-			ownerGeneration,
-			code: message.code,
-			detailCode,
-			origin: message.origin,
-			message: message.message,
-			retryable,
-			acp,
-			...outputAlreadyEmitted === void 0 ? {} : { outputAlreadyEmitted }
-		};
-	}
-	return null;
+}
+function parsePermissionEscalationOwnerMessage(message, context) {
+	if (!isPermissionEscalationEvent(message.event)) return null;
+	return {
+		type: "permission_escalation",
+		...context,
+		event: message.event
+	};
+}
+function parseResultOwnerMessage(message, context) {
+	const result = parseSessionSendResult(message.result);
+	if (!result) return null;
+	return {
+		type: "result",
+		...context,
+		result
+	};
+}
+function parseBooleanResultOwnerMessage(message, context, type, field) {
+	if (typeof message[field] !== "boolean") return null;
+	return {
+		type,
+		...context,
+		[field]: message[field]
+	};
+}
+function parseStringResultOwnerMessage(message, context, type, field) {
+	if (typeof message[field] !== "string") return null;
+	return {
+		type,
+		...context,
+		[field]: message[field]
+	};
+}
+function parseSetConfigOptionOwnerMessage(message, context) {
+	const response = asRecord$2(message.response);
+	if (!response || !Array.isArray(response.configOptions)) return null;
+	return {
+		type: "set_config_option_result",
+		...context,
+		response
+	};
+}
+function parseErrorOwnerMessage(message, context) {
+	if (!isValidOwnerErrorCore(message)) return null;
+	const outputAlreadyEmitted = typeof message.outputAlreadyEmitted === "boolean" ? message.outputAlreadyEmitted : void 0;
+	return {
+		type: "error",
+		...context,
+		code: message.code,
+		detailCode: parseNonEmptyString(message.detailCode) ?? void 0,
+		origin: message.origin,
+		message: message.message,
+		retryable: typeof message.retryable === "boolean" ? message.retryable : void 0,
+		acp: toAcpErrorPayload(message.acp),
+		...outputAlreadyEmitted === void 0 ? {} : { outputAlreadyEmitted }
+	};
+}
+function isValidOwnerErrorCore(message) {
+	return typeof message.message === "string" && isOutputErrorCode(message.code) && isOutputErrorOrigin(message.origin);
 }
 //#endregion
 //#region src/cli/queue/ipc-server.ts
@@ -753,6 +847,135 @@ var SessionQueueOwner = class SessionQueueOwner {
 			if (!options.socket.destroyed) options.socket.end();
 		});
 	}
+	failRequest(socket, requestId, message, detailCode) {
+		writeQueueMessage(socket, {
+			...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
+			ownerGeneration: this.ownerGeneration
+		});
+		socket.end();
+	}
+	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;
+	}
+	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.controlHandlers.cancelPrompt()
+				})
+			});
+			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 () => {
+					await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
+					return {
+						type: "set_model_result",
+						requestId: request.requestId,
+						modelId: request.modelId
+					};
+				}
+			});
+			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) {
+		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,
+			enqueuedAt: Date.now(),
+			send: (message) => {
+				writeQueueMessage(socket, {
+					...message,
+					ownerGeneration: this.ownerGeneration
+				});
+			},
+			close: () => {
+				if (!socket.destroyed) socket.end();
+			}
+		};
+		writeQueueMessage(socket, {
+			type: "accepted",
+			requestId: request.requestId,
+			ownerGeneration: this.ownerGeneration
+		});
+		if (!request.waitForCompletion) task.close();
+		this.enqueue(task);
+	}
 	handleConnection(socket) {
 		socket.setEncoding("utf8");
 		if (this.closed) {
@@ -762,129 +985,17 @@ var SessionQueueOwner = class SessionQueueOwner {
 		}
 		let buffer = "";
 		let handled = false;
-		const fail = (requestId, message, detailCode) => {
-			writeQueueMessage(socket, {
-				...makeQueueOwnerError(requestId, message, detailCode, { retryable: false }),
-				ownerGeneration: this.ownerGeneration
-			});
-			socket.end();
-		};
 		const processLine = (line) => {
 			if (handled) return;
 			handled = true;
-			let parsed;
-			try {
-				parsed = JSON.parse(line);
-			} catch {
-				fail("unknown", "Invalid queue request payload", "QUEUE_REQUEST_PAYLOAD_INVALID_JSON");
-				return;
-			}
-			const request = parseQueueRequest(parsed);
-			if (!request) {
-				fail("unknown", "Invalid queue request", "QUEUE_REQUEST_INVALID");
-				return;
-			}
-			if (request.ownerGeneration !== void 0 && this.ownerGeneration !== void 0 && request.ownerGeneration !== this.ownerGeneration) {
-				fail(request.requestId, "Queue request targeted a stale queue owner generation", "QUEUE_OWNER_GENERATION_MISMATCH");
-				return;
-			}
-			if (request.type === "cancel_prompt") {
-				this.handleControlRequest({
-					socket,
-					requestId: request.requestId,
-					run: async () => ({
-						type: "cancel_result",
-						requestId: request.requestId,
-						cancelled: await this.controlHandlers.cancelPrompt()
-					})
-				});
-				return;
-			}
-			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;
-			}
-			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;
-			}
-			if (request.type === "set_model") {
-				this.handleControlRequest({
-					socket,
-					requestId: request.requestId,
-					run: async () => {
-						await this.controlHandlers.setSessionModel(request.modelId, request.timeoutMs);
-						return {
-							type: "set_model_result",
-							requestId: request.requestId,
-							modelId: request.modelId
-						};
-					}
-				});
-				return;
-			}
-			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)
-					})
-				});
+			const request = this.parseRequestLine(socket, line);
+			if (!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;
 			}
-			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,
-				enqueuedAt: Date.now(),
-				send: (message) => {
-					writeQueueMessage(socket, {
-						...message,
-						ownerGeneration: this.ownerGeneration
-					});
-				},
-				close: () => {
-					if (!socket.destroyed) socket.end();
-				}
-			};
-			writeQueueMessage(socket, {
-				type: "accepted",
-				requestId: request.requestId,
-				ownerGeneration: this.ownerGeneration
-			});
-			if (!request.waitForCompletion) task.close();
-			this.enqueue(task);
+			this.enqueuePromptRequest(socket, request);
 		};
 		socket.on("data", (chunk) => {
 			buffer += chunk;
@@ -920,6 +1031,16 @@ function assertOwnerGeneration(owner, message) {
 	});
 	return message;
 }
+function queueConnectionErrorFromOwner(message, outputAlreadyEmitted) {
+	return new QueueConnectionError(message.message, {
+		outputCode: message.code,
+		detailCode: message.detailCode,
+		origin: message.origin ?? "queue",
+		retryable: message.retryable,
+		acp: message.acp,
+		...outputAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
+	});
+}
 function makeMalformedQueueMessageError() {
 	return new QueueProtocolError("Queue owner sent malformed message", {
 		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
@@ -927,6 +1048,22 @@ function makeMalformedQueueMessageError() {
 		retryable: true
 	});
 }
+function emitQueueOwnerError(formatter, policy, sessionId, message) {
+	formatter.setContext({ sessionId });
+	const queueErrorAlreadyEmitted = policy?.queueErrorAlreadyEmitted ?? true;
+	if (message.outputAlreadyEmitted !== true || !queueErrorAlreadyEmitted) {
+		formatter.onError({
+			code: message.code ?? "RUNTIME",
+			detailCode: message.detailCode,
+			origin: message.origin ?? "queue",
+			message: message.message,
+			retryable: message.retryable,
+			acp: message.acp
+		});
+		formatter.flush();
+	}
+	return queueConnectionErrorFromOwner(message, queueErrorAlreadyEmitted);
+}
 function parseQueueOwnerResponseLine(owner, requestId, line) {
 	let parsed;
 	try {
@@ -1011,6 +1148,47 @@ async function runQueueOwnerRequest(options) {
 		socket.write(`${JSON.stringify(options.request)}\n`);
 	});
 }
+function missingQueueAckError() {
+	return new QueueConnectionError("Queue owner did not acknowledge request", {
+		detailCode: "QUEUE_ACK_MISSING",
+		origin: "queue",
+		retryable: true
+	});
+}
+function unexpectedQueueResponseError() {
+	return new QueueProtocolError("Queue owner returned unexpected response", {
+		detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function handleAcknowledgedSubmitMessage(message, controls, formatter) {
+	if (message.type === "event") {
+		formatter.onAcpMessage(message.message);
+		return;
+	}
+	if (message.type === "permission_escalation") {
+		formatter.onPermissionEscalation(message.event);
+		return;
+	}
+	if (message.type === "result") {
+		formatter.flush();
+		controls.resolve(message.result);
+		return;
+	}
+	controls.reject(unexpectedQueueResponseError());
+}
+function handleSubmitQueueOwnerMessage(message, controls, options) {
+	if (message.type === "error") {
+		controls.reject(emitQueueOwnerError(options.outputFormatter, options.errorEmissionPolicy, options.sessionId, message));
+		return;
+	}
+	if (!controls.state.acknowledged) {
+		controls.reject(missingQueueAckError());
+		return;
+	}
+	handleAcknowledgedSubmitMessage(message, controls, options.outputFormatter);
+}
 async function submitToQueueOwner(owner, options) {
 	const requestId = randomUUID();
 	const request = {
@@ -1041,57 +1219,8 @@ async function submitToQueueOwner(owner, options) {
 				requestId
 			});
 		},
-		onMessage: (message, { state, resolve, reject }) => {
-			if (message.type === "error") {
-				options.outputFormatter.setContext({ sessionId: options.sessionId });
-				const queueErrorAlreadyEmitted = options.errorEmissionPolicy?.queueErrorAlreadyEmitted ?? true;
-				if (!(message.outputAlreadyEmitted === true) || !queueErrorAlreadyEmitted) {
-					options.outputFormatter.onError({
-						code: message.code ?? "RUNTIME",
-						detailCode: message.detailCode,
-						origin: message.origin ?? "queue",
-						message: message.message,
-						retryable: message.retryable,
-						acp: message.acp
-					});
-					options.outputFormatter.flush();
-				}
-				reject(new QueueConnectionError(message.message, {
-					outputCode: message.code,
-					detailCode: message.detailCode,
-					origin: message.origin ?? "queue",
-					retryable: message.retryable,
-					acp: message.acp,
-					...queueErrorAlreadyEmitted ? { outputAlreadyEmitted: true } : {}
-				}));
-				return;
-			}
-			if (!state.acknowledged) {
-				reject(new QueueConnectionError("Queue owner did not acknowledge request", {
-					detailCode: "QUEUE_ACK_MISSING",
-					origin: "queue",
-					retryable: true
-				}));
-				return;
-			}
-			if (message.type === "event") {
-				options.outputFormatter.onAcpMessage(message.message);
-				return;
-			}
-			if (message.type === "permission_escalation") {
-				options.outputFormatter.onPermissionEscalation(message.event);
-				return;
-			}
-			if (message.type === "result") {
-				options.outputFormatter.flush();
-				resolve(message.result);
-				return;
-			}
-			reject(new QueueProtocolError("Queue owner returned unexpected response", {
-				detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
-				origin: "queue",
-				retryable: true
-			}));
+		onMessage: (message, controls) => {
+			handleSubmitQueueOwnerMessage(message, controls, options);
 		},
 		onClose: ({ state, resolve, reject }) => {
 			if (!state.acknowledged) {
@@ -1520,31 +1649,19 @@ async function closeSession(sessionId) {
 //#region src/cli/session/session-management.ts
 async function createSessionRecordWithClient(client, options) {
 	const cwd = absolutePath(options.cwd);
-	await withTimeout(client.start(), options.timeoutMs);
-	let sessionId;
-	let agentSessionId;
-	let sessionResult;
-	let sessionModels;
-	let requestedModelApplied = false;
-	if (options.resumeSessionId) {
-		if (!client.supportsLoadSession()) throw new Error(`Agent command "${options.agentCommand}" does not support session/load; cannot resume session ${options.resumeSessionId}`);
-		try {
-			const loadedSession = await withTimeout(client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
-			sessionId = options.resumeSessionId;
-			agentSessionId = normalizeRuntimeSessionId(loadedSession.agentSessionId);
-			sessionResult = loadedSession;
-			sessionModels = loadedSession.models;
-			requestedModelApplied = await applyRequestedModelIfAdvertised({
-				client,
-				sessionId,
-				requestedModel: options.sessionOptions?.model,
-				models: sessionModels,
-				agentCommand: options.agentCommand,
-				timeoutMs: options.timeoutMs
-			});
-		} catch (error) {
-			throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
-		}
+	await withTimeout(client.start(), options.timeoutMs);
+	let sessionId;
+	let agentSessionId;
+	let sessionResult;
+	let sessionModels;
+	let requestedModelApplied = false;
+	if (options.resumeSessionId) {
+		const resumed = await resumeSessionRecordWithClient(client, options, cwd);
+		sessionId = resumed.sessionId;
+		agentSessionId = resumed.agentSessionId;
+		sessionResult = resumed.sessionResult;
+		sessionModels = resumed.sessionModels;
+		requestedModelApplied = resumed.requestedModelApplied;
 	} else {
 		const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
 		sessionId = createdSession.sessionId;
@@ -1577,7 +1694,7 @@ async function createSessionRecordWithClient(client, options) {
 		eventLog: defaultSessionEventLog(sessionId),
 		closed: false,
 		closedAt: void 0,
-		pid: lifecycle.pid,
+		pid: lifecycle.running ? lifecycle.pid : void 0,
 		agentStartedAt: lifecycle.startedAt,
 		protocolVersion: client.initializeResult?.protocolVersion,
 		agentCapabilities: client.initializeResult?.agentCapabilities,
@@ -1591,6 +1708,31 @@ async function createSessionRecordWithClient(client, options) {
 	await writeSessionRecord(record);
 	return record;
 }
+async function resumeSessionRecordWithClient(client, options, cwd) {
+	if (!options.resumeSessionId) throw new Error("resumeSessionId is required");
+	const resumeMethod = client.supportsResumeSession() ? "session/resume" : client.supportsLoadSession() ? "session/load" : void 0;
+	if (!resumeMethod) throw new Error(`Agent command "${options.agentCommand}" does not support session/resume or session/load; cannot resume session ${options.resumeSessionId}`);
+	try {
+		const resumedSession = await withTimeout(resumeMethod === "session/resume" ? client.resumeSession(options.resumeSessionId, cwd) : client.loadSession(options.resumeSessionId, cwd), options.timeoutMs);
+		const sessionModels = resumedSession.models;
+		return {
+			sessionId: options.resumeSessionId,
+			agentSessionId: normalizeRuntimeSessionId(resumedSession.agentSessionId),
+			sessionResult: resumedSession,
+			sessionModels,
+			requestedModelApplied: await applyRequestedModelIfAdvertised({
+				client,
+				sessionId: options.resumeSessionId,
+				requestedModel: options.sessionOptions?.model,
+				models: sessionModels,
+				agentCommand: options.agentCommand,
+				timeoutMs: options.timeoutMs
+			})
+		};
+	} catch (error) {
+		throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
+	}
+}
 async function createSessionWithClient(options) {
 	const client = new AcpClient({
 		agentCommand: options.agentCommand,
@@ -1621,6 +1763,45 @@ async function createSession(options) {
 	const { record, client } = await createSessionWithClient(options);
 	try {
 		return record;
+	} finally {
+		await client.close();
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		await writeSessionRecord(record);
+	}
+}
+async function listAgentSessions(options) {
+	const client = new AcpClient({
+		agentCommand: options.agentCommand,
+		cwd: absolutePath(options.cwd),
+		mcpServers: options.mcpServers,
+		permissionMode: options.permissionMode,
+		nonInteractivePermissions: options.nonInteractivePermissions,
+		permissionPolicy: options.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		terminal: options.terminal,
+		verbose: options.verbose
+	});
+	try {
+		return await withInterrupt(async () => {
+			await withTimeout(client.start(), options.timeoutMs);
+			if (!client.supportsListSessions()) return;
+			const cwd = options.filterCwd ? absolutePath(options.filterCwd) : void 0;
+			const response = await withTimeout(client.listSessions({
+				...cwd ? { cwd } : {},
+				...options.cursor ? { cursor: options.cursor } : {}
+			}), options.timeoutMs);
+			return {
+				_meta: response._meta,
+				source: "agent",
+				sessions: response.sessions,
+				cursor: options.cursor,
+				cwd,
+				nextCursor: response.nextCursor
+			};
+		}, async () => {
+			await client.close();
+		});
 	} finally {
 		await client.close();
 	}
@@ -1701,15 +1882,25 @@ function buildPayload(reason) {
 		metrics: getPerfMetricsSnapshot()
 	};
 }
+function payloadHasMetrics(payload) {
+	const metrics = payload.metrics;
+	return [
+		metrics.counters,
+		metrics.gauges,
+		metrics.timings
+	].some((entries) => Object.keys(entries ?? {}).length > 0);
+}
+function appendPerfMetricsPayload(payload) {
+	fs.mkdirSync(path.dirname(captureFilePath), { recursive: true });
+	fs.appendFileSync(captureFilePath, `${JSON.stringify(payload)}\n`, "utf8");
+	captureSequence += 1;
+}
 function writePerfMetricsCapture(reason, resetAfterWrite) {
 	if (!shouldCapture()) return false;
 	const payload = buildPayload(reason);
-	const metrics = payload.metrics;
-	if (!(Object.keys(metrics.counters ?? {}).length > 0 || Object.keys(metrics.gauges ?? {}).length > 0 || Object.keys(metrics.timings ?? {}).length > 0)) return false;
+	if (!payloadHasMetrics(payload)) return false;
 	try {
-		fs.mkdirSync(path.dirname(captureFilePath), { recursive: true });
-		fs.appendFileSync(captureFilePath, `${JSON.stringify(payload)}\n`, "utf8");
-		captureSequence += 1;
+		appendPerfMetricsPayload(payload);
 		if (resetAfterWrite) resetPerfMetrics();
 		return true;
 	} catch {
@@ -1839,20 +2030,53 @@ var QueueOwnerTurnController = class {
 };
 //#endregion
 //#region src/cli/session/queue-owner-process.ts
+function isNonEmptyStringArray(value) {
+	return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
+}
+const NODE_TEST_FLAGS = new Set([
+	"--experimental-test-coverage",
+	"--test",
+	"--test-name-pattern",
+	"--test-reporter",
+	"--test-reporter-destination"
+]);
+const NODE_TEST_FLAGS_WITH_VALUE = new Set([
+	"--test-name-pattern",
+	"--test-reporter",
+	"--test-reporter-destination"
+]);
+const INSPECTOR_FLAGS_WITH_VALUE = new Set([
+	"--inspect",
+	"--inspect-brk",
+	"--inspect-port",
+	"--inspect-publish-uid",
+	"--debug-port"
+]);
+const INSPECTOR_FLAG_PREFIXES = [
+	"--inspect=",
+	"--inspect-brk=",
+	"--inspect-port=",
+	"--inspect-publish-uid=",
+	"--debug-port="
+];
+function classifyExecArgv(value) {
+	if (value === void 0) return "drop";
+	if (NODE_TEST_FLAGS_WITH_VALUE.has(value) || INSPECTOR_FLAGS_WITH_VALUE.has(value)) return "drop-with-value";
+	return dropSingleExecArgv(value) ? "drop" : "keep";
+}
+function dropSingleExecArgv(value) {
+	return NODE_TEST_FLAGS.has(value) || value.startsWith("--test-") || INSPECTOR_FLAG_PREFIXES.some((prefix) => value.startsWith(prefix));
+}
 function sanitizeQueueOwnerExecArgv(execArgv = process.execArgv) {
 	const sanitized = [];
 	for (let index = 0; index < execArgv.length; index += 1) {
-		const value = execArgv[index];
-		if (value === "--experimental-test-coverage" || value === "--test") continue;
-		if (value === "--test-name-pattern" || value === "--test-reporter" || value === "--test-reporter-destination") {
+		const value = execArgv[index] ?? "";
+		const decision = classifyExecArgv(value);
+		if (decision === "drop") continue;
+		if (decision === "drop-with-value") {
 			index += 1;
 			continue;
 		}
-		if (value.startsWith("--test-")) continue;
-		if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value.startsWith("--inspect=") || value.startsWith("--inspect-brk=") || value.startsWith("--inspect-port=") || value.startsWith("--inspect-publish-uid=") || value === "--debug-port" || value.startsWith("--debug-port=")) {
-			if (value === "--inspect" || value === "--inspect-brk" || value === "--inspect-port" || value === "--inspect-publish-uid" || value === "--debug-port") index += 1;
-			continue;
-		}
 		sanitized.push(value);
 	}
 	return sanitized;
@@ -1870,7 +2094,7 @@ function resolveQueueOwnerSpawnArgs(argv = process.argv) {
 	const override = process.env.ACPX_QUEUE_OWNER_ARGS;
 	if (override) {
 		const parsed = JSON.parse(override);
-		if (Array.isArray(parsed) && parsed.length > 0 && parsed.every((value) => typeof value === "string" && value.length > 0)) return [...parsed];
+		if (isNonEmptyStringArray(parsed)) return [...parsed];
 		throw new Error("acpx self-spawn failed: invalid ACPX_QUEUE_OWNER_ARGS");
 	}
 	const entry = argv[1];
@@ -1937,6 +2161,10 @@ async function countExistingSegments(sessionId, maxSegments) {
 	if (await pathExists(sessionEventActivePath(sessionId))) count += 1;
 	return count;
 }
+async function resolveInitialSegmentCount(record, maxSegments) {
+	if (Number.isInteger(record.eventLog.segment_count) && record.eventLog.segment_count > 0) return record.eventLog.segment_count;
+	return await countExistingSegments(record.acpxRecordId, maxSegments) || 1;
+}
 async function rotateSegments(sessionId, maxSegments) {
 	const active = sessionEventActivePath(sessionId);
 	const overflow = sessionEventSegmentPath(sessionId, maxSegments);
@@ -2028,7 +2256,7 @@ var SessionEventWriter = class SessionEventWriter {
 		const maxSegments = options.maxSegments ?? record.eventLog.max_segments ?? 5;
 		const activePath = sessionEventActivePath(record.acpxRecordId);
 		const activeSizeBytes = await statSize(activePath);
-		const segmentCount = Number.isInteger(record.eventLog.segment_count) && record.eventLog.segment_count > 0 ? record.eventLog.segment_count : await countExistingSegments(record.acpxRecordId, maxSegments) || 1;
+		const segmentCount = await resolveInitialSegmentCount(record, maxSegments);
 		return new SessionEventWriter(record, lock, {
 			maxSegmentBytes,
 			maxSegments
@@ -2148,23 +2376,31 @@ function toPromptResult(stopReason, sessionId, client) {
 		permissionStats: client.getPermissionStats()
 	};
 }
+function requestedModelId(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function advertisedModelsForRecord(record) {
+	const availableModels = record.acpx?.available_models;
+	if (!Array.isArray(availableModels)) return;
+	return {
+		currentModelId: record.acpx?.current_model_id ?? "",
+		availableModels: availableModels.map((modelId) => ({
+			modelId,
+			name: modelId
+		}))
+	};
+}
 async function applyPromptModelIfAdvertised(params) {
-	const requestedModel = typeof params.requestedModel === "string" ? params.requestedModel.trim() : "";
+	const requestedModel = requestedModelId(params.requestedModel);
 	if (!requestedModel) return;
-	const availableModels = params.record.acpx?.available_models;
+	const models = advertisedModelsForRecord(params.record);
 	assertRequestedModelSupported({
 		requestedModel,
-		models: Array.isArray(availableModels) ? {
-			currentModelId: params.record.acpx?.current_model_id ?? "",
-			availableModels: availableModels.map((modelId) => ({
-				modelId,
-				name: modelId
-			}))
-		} : void 0,
+		models,
 		agentCommand: params.record.agentCommand,
 		context: "apply"
 	});
-	if (!Array.isArray(availableModels)) return;
+	if (!models) return;
 	if (params.record.acpx?.current_model_id === requestedModel) {
 		setDesiredModelId(params.record, requestedModel);
 		return;
@@ -2198,6 +2434,7 @@ function extractJsonRpcResponseInfo(message) {
 		hasError
 	};
 }
+const SESSION_RECONNECT_METHODS = new Set(["session/load", "session/resume"]);
 function filterRecoverableLoadFallbackOutput(messages) {
 	const requestMethodById = /* @__PURE__ */ new Map();
 	const failedLoadRequestIds = /* @__PURE__ */ new Set();
@@ -2209,12 +2446,13 @@ function filterRecoverableLoadFallbackOutput(messages) {
 		}
 		const response = extractJsonRpcResponseInfo(message);
 		if (!response || !response.hasError) continue;
-		if (requestMethodById.get(response.idKey) === "session/load") failedLoadRequestIds.add(response.idKey);
+		const requestMethod = requestMethodById.get(response.idKey);
+		if (requestMethod && SESSION_RECONNECT_METHODS.has(requestMethod)) failedLoadRequestIds.add(response.idKey);
 	}
 	if (failedLoadRequestIds.size === 0) return messages;
 	return messages.filter((message) => {
 		const request = extractJsonRpcRequestInfo(message);
-		if (request && request.method === "session/load" && failedLoadRequestIds.has(request.idKey)) return false;
+		if (request && SESSION_RECONNECT_METHODS.has(request.method) && failedLoadRequestIds.has(request.idKey)) return false;
 		const response = extractJsonRpcResponseInfo(message);
 		if (response && failedLoadRequestIds.has(response.idKey)) return false;
 		return true;
@@ -2224,52 +2462,97 @@ function emitPromptRetryNotice(params) {
 	if (params.suppressSdkConsoleErrors) return;
 	process.stderr.write(`[acpx] prompt failed (${formatErrorMessage(params.error)}), retrying in ${params.delayMs}ms (attempt ${params.attempt}/${params.maxRetries})\n`);
 }
+function emitConnectPerfMetric(startedAt, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] ${formatPerfMetric("prompt.connect_and_load", Date.now() - startedAt)}\n`);
+}
+function emitPromptPerfMetric(startedAt, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] ${formatPerfMetric("prompt.agent_turn", Date.now() - startedAt)}\n`);
+}
+function emitPromptHookError(error, verbose) {
+	if (!verbose) return;
+	process.stderr.write("[acpx] onPromptActive hook failed: " + formatErrorMessage(error) + "\n");
+}
+function emitPromptDisconnectNotice(snapshot, verbose) {
+	const lastExit = snapshot.lastExit;
+	if (!lastExit?.unexpectedDuringPrompt || !verbose) return;
+	process.stderr.write("[acpx] agent disconnected during prompt (" + lastExit.reason + ", exit=" + lastExit.exitCode + ", signal=" + (lastExit.signal ?? "none") + ")\n");
+}
+function shouldRetryRuntimePrompt(error, attempt, maxRetries, snapshot, hasSideEffects) {
+	if (!shouldRetryPromptAttempt(error, attempt, maxRetries, hasSideEffects)) return false;
+	return snapshot.lastExit?.unexpectedDuringPrompt !== true;
+}
+function shouldRetryPromptAttempt(error, attempt, maxRetries, hasSideEffects) {
+	return attempt < maxRetries && !hasSideEffects() && isRetryablePromptError(error);
+}
+async function waitBeforePromptRetry(error, attempt, maxRetries, suppressSdkConsoleErrors) {
+	const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+	emitPromptRetryNotice({
+		error,
+		delayMs,
+		attempt: attempt + 1,
+		maxRetries,
+		suppressSdkConsoleErrors
+	});
+	await waitMs(delayMs);
+}
+function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatter) {
+	return {
+		sessionRecordId,
+		mcpServers: options.mcpServers,
+		prompt: task.prompt ?? textPrompt(task.message),
+		permissionMode: task.permissionMode,
+		resumePolicy: task.resumePolicy,
+		nonInteractivePermissions: task.nonInteractivePermissions ?? options.nonInteractivePermissions,
+		permissionPolicy: task.permissionPolicy,
+		authCredentials: options.authCredentials,
+		authPolicy: options.authPolicy,
+		outputFormatter,
+		timeoutMs: task.timeoutMs,
+		suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
+		verbose: options.verbose,
+		promptRetries: task.promptRetries ?? options.promptRetries ?? 0,
+		sessionOptions: mergeSessionOptions(task.sessionOptions, options.sessionOptions),
+		onClientAvailable: options.onClientAvailable,
+		onClientClosed: options.onClientClosed,
+		onPromptActive: options.onPromptActive,
+		client: options.sharedClient
+	};
+}
+function sendQueuedTaskResult(task, result) {
+	if (!task.waitForCompletion) return;
+	task.send({
+		type: "result",
+		requestId: task.requestId,
+		result
+	});
+}
+function sendQueuedTaskError(task, error) {
+	if (!task.waitForCompletion) return;
+	const normalizedError = normalizeOutputError(error, {
+		origin: "runtime",
+		detailCode: "QUEUE_RUNTIME_PROMPT_FAILED"
+	});
+	const alreadyEmitted = error.outputAlreadyEmitted === true;
+	task.send({
+		type: "error",
+		requestId: task.requestId,
+		code: normalizedError.code,
+		detailCode: normalizedError.detailCode,
+		origin: normalizedError.origin,
+		message: normalizedError.message,
+		retryable: normalizedError.retryable,
+		acp: normalizedError.acp,
+		outputAlreadyEmitted: alreadyEmitted
+	});
+}
 async function runQueuedTask(sessionRecordId, task, options) {
 	const outputFormatter = task.waitForCompletion ? new QueueTaskOutputFormatter(task) : DISCARD_OUTPUT_FORMATTER;
 	try {
-		const result = await runSessionPrompt({
-			sessionRecordId,
-			mcpServers: options.mcpServers,
-			prompt: task.prompt ?? textPrompt(task.message),
-			permissionMode: task.permissionMode,
-			resumePolicy: task.resumePolicy,
-			nonInteractivePermissions: task.nonInteractivePermissions ?? options.nonInteractivePermissions,
-			permissionPolicy: task.permissionPolicy,
-			authCredentials: options.authCredentials,
-			authPolicy: options.authPolicy,
-			outputFormatter,
-			timeoutMs: task.timeoutMs,
-			suppressSdkConsoleErrors: task.suppressSdkConsoleErrors ?? options.suppressSdkConsoleErrors,
-			verbose: options.verbose,
-			promptRetries: task.promptRetries ?? options.promptRetries ?? 0,
-			sessionOptions: mergeSessionOptions(task.sessionOptions, options.sessionOptions),
-			onClientAvailable: options.onClientAvailable,
-			onClientClosed: options.onClientClosed,
-			onPromptActive: options.onPromptActive,
-			client: options.sharedClient
-		});
-		if (task.waitForCompletion) task.send({
-			type: "result",
-			requestId: task.requestId,
-			result
-		});
+		sendQueuedTaskResult(task, await runSessionPrompt(buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatter)));
 	} catch (error) {
-		const normalizedError = normalizeOutputError(error, {
-			origin: "runtime",
-			detailCode: "QUEUE_RUNTIME_PROMPT_FAILED"
-		});
-		const alreadyEmitted = error.outputAlreadyEmitted === true;
-		if (task.waitForCompletion) task.send({
-			type: "error",
-			requestId: task.requestId,
-			code: normalizedError.code,
-			detailCode: normalizedError.detailCode,
-			origin: normalizedError.origin,
-			message: normalizedError.message,
-			retryable: normalizedError.retryable,
-			acp: normalizedError.acp,
-			outputAlreadyEmitted: alreadyEmitted
-		});
+		sendQueuedTaskError(task, error);
 		if (error instanceof InterruptedError) throw error;
 	} finally {
 		task.close();
@@ -2408,41 +2691,117 @@ async function runSessionPrompt(options) {
 			return await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
 		}
 	};
+	const flushConnectOutput = (loadError) => {
+		bufferingConnectOutput = false;
+		const messages = loadError == null ? pendingConnectOutputMessages : filterRecoverableLoadFallbackOutput(pendingConnectOutputMessages);
+		for (const message of messages) output.onAcpMessage(message);
+		pendingConnectOutputMessages.length = 0;
+	};
+	const connectForPrompt = async () => {
+		const connectStartedAt = Date.now();
+		try {
+			const connected = await measurePerf("runtime.connect_and_load", async () => {
+				return await connectAndLoadSession({
+					client,
+					record,
+					resumePolicy: options.resumePolicy,
+					timeoutMs: options.timeoutMs,
+					verbose: options.verbose,
+					activeController,
+					onClientAvailable: (controller) => {
+						options.onClientAvailable?.(controller);
+						notifiedClientAvailable = true;
+					},
+					onConnectedRecord: (connectedRecord) => {
+						connectedRecord.lastPromptAt = isoNow();
+					},
+					onSessionIdResolved: (sessionId) => {
+						activeSessionIdForControl = sessionId;
+					}
+				});
+			});
+			flushConnectOutput(connected.loadError);
+			emitConnectPerfMetric(connectStartedAt, options.verbose);
+			return connected;
+		} catch (error) {
+			flushConnectOutput();
+			throw error;
+		}
+	};
+	const buildPromptStartedHook = (attempt) => {
+		if (attempt !== 0 || !options.onPromptActive) return;
+		return async () => {
+			try {
+				await options.onPromptActive?.();
+			} catch (error) {
+				emitPromptHookError(error, options.verbose);
+			}
+		};
+	};
+	const runPromptAttempt = async (sessionId, attempt) => {
+		const promptStartedAt = Date.now();
+		const response = await measurePerf("runtime.prompt.agent_turn", async () => {
+			return await runPromptTurn({
+				client,
+				sessionId,
+				prompt: options.prompt,
+				timeoutMs: options.timeoutMs,
+				conversation,
+				promptMessageId,
+				onPromptStarted: buildPromptStartedHook(attempt)
+			});
+		});
+		emitPromptPerfMetric(promptStartedAt, options.verbose);
+		return response;
+	};
+	const handlePromptFailure = async (error, attempt) => {
+		const snapshot = client.getAgentLifecycleSnapshot();
+		if (shouldRetryRuntimePrompt(error, attempt, options.promptRetries ?? 0, snapshot, () => promptTurnHadSideEffects)) {
+			await waitBeforePromptRetry(error, attempt, options.promptRetries ?? 0, options.suppressSdkConsoleErrors);
+			return promptTurnHadSideEffects ? await failRuntimePrompt(error, snapshot) : "retry";
+		}
+		return await failRuntimePrompt(error, snapshot);
+	};
+	const failRuntimePrompt = async (error, snapshot) => {
+		promptTurnActive = false;
+		applyLifecycleSnapshotToRecord(record, snapshot);
+		emitPromptDisconnectNotice(snapshot, options.verbose);
+		const normalizedError = normalizeOutputError(error, { origin: "runtime" });
+		await flushPendingMessages(false).catch(() => {});
+		output.flush();
+		record.lastUsedAt = isoNow();
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
+		propagated.outputAlreadyEmitted = sawAcpMessage;
+		propagated.normalizedOutputError = normalizedError;
+		throw propagated;
+	};
+	const runPromptWithRetries = async (sessionId) => {
+		promptTurnActive = true;
+		for (let attempt = 0;; attempt++) try {
+			return await runPromptAttempt(sessionId, attempt);
+		} catch (error) {
+			if (await handlePromptFailure(error, attempt) === "retry") continue;
+		}
+	};
+	const savePromptSuccess = async (response) => {
+		await flushPendingMessages(false);
+		output.flush();
+		record.lastUsedAt = isoNow();
+		record.closed = false;
+		record.closedAt = void 0;
+		record.protocolVersion = client.initializeResult?.protocolVersion;
+		record.agentCapabilities = client.initializeResult?.agentCapabilities;
+		applyConversation(record, conversation);
+		record.acpx = acpxState;
+		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
+		stopTotalTimer();
+		return response;
+	};
 	try {
 		return await withInterrupt(async () => {
-			const connectStartedAt = Date.now();
-			const { sessionId: activeSessionId, resumed, loadError } = await measurePerf("runtime.connect_and_load", async () => {
-				try {
-					return await connectAndLoadSession({
-						client,
-						record,
-						resumePolicy: options.resumePolicy,
-						timeoutMs: options.timeoutMs,
-						verbose: options.verbose,
-						activeController,
-						onClientAvailable: (controller) => {
-							options.onClientAvailable?.(controller);
-							notifiedClientAvailable = true;
-						},
-						onConnectedRecord: (connectedRecord) => {
-							connectedRecord.lastPromptAt = isoNow();
-						},
-						onSessionIdResolved: (sessionId) => {
-							activeSessionIdForControl = sessionId;
-						}
-					});
-				} catch (error) {
-					bufferingConnectOutput = false;
-					for (const message of pendingConnectOutputMessages) output.onAcpMessage(message);
-					pendingConnectOutputMessages.length = 0;
-					throw error;
-				}
-			});
-			bufferingConnectOutput = false;
-			const connectOutputMessages = loadError == null ? pendingConnectOutputMessages : filterRecoverableLoadFallbackOutput(pendingConnectOutputMessages);
-			for (const message of connectOutputMessages) output.onAcpMessage(message);
-			pendingConnectOutputMessages.length = 0;
-			if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.connect_and_load", Date.now() - connectStartedAt)}\n`);
+			const { sessionId: activeSessionId, resumed, loadError } = await connectForPrompt();
 			await applyPromptModelIfAdvertised({
 				client,
 				sessionId: activeSessionId,
@@ -2452,72 +2811,8 @@ async function runSessionPrompt(options) {
 			});
 			output.setContext({ sessionId: record.acpxRecordId });
 			await liveCheckpoint.checkpoint();
-			const maxRetries = options.promptRetries ?? 0;
-			let response;
-			promptTurnActive = true;
-			for (let attempt = 0;; attempt++) try {
-				const promptStartedAt = Date.now();
-				response = await measurePerf("runtime.prompt.agent_turn", async () => {
-					return await runPromptTurn({
-						client,
-						sessionId: activeSessionId,
-						prompt: options.prompt,
-						timeoutMs: options.timeoutMs,
-						conversation,
-						promptMessageId,
-						onPromptStarted: attempt === 0 && options.onPromptActive ? async () => {
-							try {
-								await options.onPromptActive?.();
-							} catch (error) {
-								if (options.verbose) process.stderr.write("[acpx] onPromptActive hook failed: " + formatErrorMessage(error) + "\n");
-							}
-						} : void 0
-					});
-				});
-				if (options.verbose) process.stderr.write(`[acpx] ${formatPerfMetric("prompt.agent_turn", Date.now() - promptStartedAt)}\n`);
-				break;
-			} catch (error) {
-				const snapshot = client.getAgentLifecycleSnapshot();
-				const agentCrashed = snapshot.lastExit?.unexpectedDuringPrompt === true;
-				if (attempt < maxRetries && !agentCrashed && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
-					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
-					emitPromptRetryNotice({
-						error,
-						delayMs,
-						attempt: attempt + 1,
-						maxRetries,
-						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
-					});
-					await waitMs(delayMs);
-					if (!promptTurnHadSideEffects) continue;
-				}
-				promptTurnActive = false;
-				applyLifecycleSnapshotToRecord(record, snapshot);
-				const lastExit = snapshot.lastExit;
-				if (lastExit?.unexpectedDuringPrompt && options.verbose) process.stderr.write("[acpx] agent disconnected during prompt (" + lastExit.reason + ", exit=" + lastExit.exitCode + ", signal=" + (lastExit.signal ?? "none") + ")\n");
-				const normalizedError = normalizeOutputError(error, { origin: "runtime" });
-				await flushPendingMessages(false).catch(() => {});
-				output.flush();
-				record.lastUsedAt = isoNow();
-				applyConversation(record, conversation);
-				record.acpx = acpxState;
-				const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
-				propagated.outputAlreadyEmitted = sawAcpMessage;
-				propagated.normalizedOutputError = normalizedError;
-				throw propagated;
-			}
+			const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
 			promptTurnActive = false;
-			await flushPendingMessages(false);
-			output.flush();
-			record.lastUsedAt = isoNow();
-			record.closed = false;
-			record.closedAt = void 0;
-			record.protocolVersion = client.initializeResult?.protocolVersion;
-			record.agentCapabilities = client.initializeResult?.agentCapabilities;
-			applyConversation(record, conversation);
-			record.acpx = acpxState;
-			applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
-			stopTotalTimer();
 			return {
 				...toPromptResult(response.stopReason, record.acpxRecordId, client),
 				record,
@@ -2580,6 +2875,25 @@ async function runOnce(options) {
 		},
 		sessionOptions: options.sessionOptions
 	});
+	const runExecPromptAttempt = async (sessionId) => {
+		return await measurePerf("runtime.exec.prompt", async () => {
+			return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
+		});
+	};
+	const runExecPromptWithRetries = async (sessionId) => {
+		const maxRetries = options.promptRetries ?? 0;
+		promptTurnActive = true;
+		for (let attempt = 0;; attempt++) try {
+			return await runExecPromptAttempt(sessionId);
+		} catch (error) {
+			if (shouldRetryPromptAttempt(error, attempt, maxRetries, () => promptTurnHadSideEffects)) {
+				await waitBeforePromptRetry(error, attempt, maxRetries, options.suppressSdkConsoleErrors);
+				if (!promptTurnHadSideEffects) continue;
+			}
+			promptTurnActive = false;
+			throw error;
+		}
+	};
 	try {
 		return await withInterrupt(async () => {
 			await measurePerf("runtime.exec.start", async () => {
@@ -2598,30 +2912,7 @@ async function runOnce(options) {
 				timeoutMs: options.timeoutMs
 			});
 			output.setContext({ sessionId });
-			const maxRetries = options.promptRetries ?? 0;
-			let response;
-			promptTurnActive = true;
-			for (let attempt = 0;; attempt++) try {
-				response = await measurePerf("runtime.exec.prompt", async () => {
-					return await withTimeout(client.prompt(sessionId, options.prompt), options.timeoutMs);
-				});
-				break;
-			} catch (error) {
-				if (attempt < maxRetries && !promptTurnHadSideEffects && isRetryablePromptError(error)) {
-					const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
-					emitPromptRetryNotice({
-						error,
-						delayMs,
-						attempt: attempt + 1,
-						maxRetries,
-						suppressSdkConsoleErrors: options.suppressSdkConsoleErrors
-					});
-					await waitMs(delayMs);
-					if (!promptTurnHadSideEffects) continue;
-				}
-				promptTurnActive = false;
-				throw error;
-			}
+			const response = await runExecPromptWithRetries(sessionId);
 			promptTurnActive = false;
 			output.flush();
 			return toPromptResult(response.stopReason, sessionId, client);
@@ -2678,13 +2969,8 @@ async function submitToRunningOwner(options, waitForCompletion) {
 		sessionOptions: options.sessionOptions
 	});
 }
-async function runSessionQueueOwner(options) {
-	const lease = await tryAcquireQueueOwnerLease(options.sessionId);
-	if (!lease) return;
-	const sessionRecord = await resolveSessionRecord(options.sessionId);
-	let owner;
-	let heartbeatTimer;
-	const sharedClient = new AcpClient({
+function createQueueOwnerSharedClient(options, sessionRecord) {
+	return new AcpClient({
 		agentCommand: sessionRecord.agentCommand,
 		cwd: absolutePath(sessionRecord.cwd),
 		mcpServers: options.mcpServers,
@@ -2697,11 +2983,9 @@ async function runSessionQueueOwner(options) {
 		verbose: options.verbose,
 		sessionOptions: mergeSessionOptions(options.sessionOptions, sessionOptionsFromRecord(sessionRecord))
 	});
-	const ttlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
-	const maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth ?? 16));
-	const taskPollTimeoutMs = ttlMs === 0 ? void 0 : ttlMs;
-	const initialTaskPollTimeoutMs = taskPollTimeoutMs == null ? void 0 : Math.max(taskPollTimeoutMs, 1e3);
-	const turnController = new QueueOwnerTurnController({
+}
+function createQueueOwnerTurnController(options) {
+	return new QueueOwnerTurnController({
 		withTimeout: async (run, timeoutMs) => await withTimeout(run(), timeoutMs),
 		setSessionModeFallback: async (modeId, timeoutMs) => {
 			await runSessionSetModeDirect({
@@ -2744,12 +3028,49 @@ async function runSessionQueueOwner(options) {
 			})).response;
 		}
 	});
+}
+function logDeferredCancelFailure(error, verbose) {
+	if (!verbose) return;
+	process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
+}
+function logQueueOwnerReady(params) {
+	if (!params.verbose) return;
+	process.stderr.write(`[acpx] queue owner ready for session ${params.sessionId} (ttlMs=${params.ttlMs}, maxQueueDepth=${params.maxQueueDepth})\n`);
+}
+async function closeQueueOwnerRuntime(params) {
+	if (params.heartbeatTimer) clearInterval(params.heartbeatTimer);
+	params.turnController.beginClosing();
+	await params.owner?.close();
+	await params.sharedClient.close().catch(() => {});
+	await writeQueueOwnerLifecycleSnapshot(params.sessionId, params.sharedClient);
+	await releaseQueueOwnerLease(params.lease);
+	if (params.verbose) process.stderr.write(`[acpx] queue owner stopped for session ${params.sessionId}\n`);
+}
+async function writeQueueOwnerLifecycleSnapshot(sessionId, sharedClient) {
+	try {
+		const record = await resolveSessionRecord(sessionId);
+		applyLifecycleSnapshotToRecord(record, sharedClient.getAgentLifecycleSnapshot());
+		await writeSessionRecord(record);
+	} catch {}
+}
+async function runSessionQueueOwner(options) {
+	const lease = await tryAcquireQueueOwnerLease(options.sessionId);
+	if (!lease) return;
+	const sessionRecord = await resolveSessionRecord(options.sessionId);
+	let owner;
+	let heartbeatTimer;
+	const sharedClient = createQueueOwnerSharedClient(options, sessionRecord);
+	const ttlMs = normalizeQueueOwnerTtlMs(options.ttlMs);
+	const maxQueueDepth = Math.max(1, Math.round(options.maxQueueDepth ?? 16));
+	const taskPollTimeoutMs = ttlMs === 0 ? void 0 : ttlMs;
+	const initialTaskPollTimeoutMs = taskPollTimeoutMs == null ? void 0 : Math.max(taskPollTimeoutMs, 1e3);
+	const turnController = createQueueOwnerTurnController(options);
 	const applyPendingCancel = async () => {
 		return await turnController.applyPendingCancel();
 	};
 	const scheduleApplyPendingCancel = () => {
 		applyPendingCancel().catch((error) => {
-			if (options.verbose) process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
+			logDeferredCancelFailure(error, options.verbose);
 		});
 	};
 	const setActiveController = (controller) => {
@@ -2797,7 +3118,12 @@ async function runSessionQueueOwner(options) {
 				refreshQueueOwnerLease(lease, { queueDepth }).catch(() => {});
 			}
 		});
-		if (options.verbose) process.stderr.write(`[acpx] queue owner ready for session ${options.sessionId} (ttlMs=${ttlMs}, maxQueueDepth=${maxQueueDepth})\n`);
+		logQueueOwnerReady({
+			sessionId: options.sessionId,
+			ttlMs,
+			maxQueueDepth,
+			verbose: options.verbose
+		});
 		await refreshQueueOwnerLease(lease, { queueDepth: owner.queueDepth() }).catch(() => {});
 		heartbeatTimer = setInterval(() => {
 			refreshQueueOwnerLease(lease, { queueDepth: owner?.queueDepth() ?? 0 }).catch(() => {});
@@ -2833,17 +3159,15 @@ async function runSessionQueueOwner(options) {
 			});
 		}
 	} finally {
-		if (heartbeatTimer) clearInterval(heartbeatTimer);
-		turnController.beginClosing();
-		if (owner) await owner.close();
-		await sharedClient.close().catch(() => {});
-		try {
-			const record = await resolveSessionRecord(options.sessionId);
-			applyLifecycleSnapshotToRecord(record, sharedClient.getAgentLifecycleSnapshot());
-			await writeSessionRecord(record);
-		} catch {}
-		await releaseQueueOwnerLease(lease);
-		if (options.verbose) process.stderr.write(`[acpx] queue owner stopped for session ${options.sessionId}\n`);
+		await closeQueueOwnerRuntime({
+			lease,
+			owner,
+			heartbeatTimer,
+			turnController,
+			sharedClient,
+			sessionId: options.sessionId,
+			verbose: options.verbose
+		});
 	}
 }
 async function sendSession(options) {
@@ -2874,6 +3198,7 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	findSession: () => findSession,
 	findSessionByDirectoryWalk: () => findSessionByDirectoryWalk,
 	isProcessAlive: () => isProcessAlive,
+	listAgentSessions: () => listAgentSessions,
 	listSessions: () => listSessions,
 	listSessionsForAgent: () => listSessionsForAgent,
 	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
@@ -2953,7 +3278,12 @@ function inferToolKindFromTitle(title) {
 	if (!normalized) return;
 	const head = normalized.split(":", 1)[0]?.trim();
 	if (!head) return;
-	if (head.includes("read") || head.includes("cat") || head.includes("open") || head.includes("view")) return "read";
+	if ([
+		"read",
+		"cat",
+		"open",
+		"view"
+	].some((needle) => head.includes(needle))) return "read";
 }
 function isReadLikeTool(tool) {
 	return tool.kind?.trim().toLowerCase() === "read" || inferToolKindFromTitle(tool.title) === "read";
@@ -2996,14 +3326,25 @@ function sanitizeToolMessage(message) {
 		...root,
 		params: {
 			...params,
-			update: {
-				...update,
-				rawOutput: Object.prototype.hasOwnProperty.call(update, "rawOutput") && update.rawOutput !== void 0 ? { content: SUPPRESSED_READ_OUTPUT } : update.rawOutput,
-				content: Object.prototype.hasOwnProperty.call(update, "content") && update.content !== void 0 ? sanitizeToolContent(update.content) : update.content
-			}
+			update: sanitizeToolUpdate(update)
 		}
 	};
 }
+function sanitizeToolUpdate(update) {
+	return {
+		...update,
+		rawOutput: sanitizedRawOutput(update),
+		content: sanitizedContent(update)
+	};
+}
+function sanitizedRawOutput(update) {
+	if (Object.prototype.hasOwnProperty.call(update, "rawOutput") && update.rawOutput !== void 0) return { content: SUPPRESSED_READ_OUTPUT };
+	return update.rawOutput;
+}
+function sanitizedContent(update) {
+	if (Object.prototype.hasOwnProperty.call(update, "content") && update.content !== void 0) return sanitizeToolContent(update.content);
+	return update.content;
+}
 var JsonOutputFormatter = class {
 	stdout;
 	suppressReads;
@@ -3052,23 +3393,30 @@ var JsonOutputFormatter = class {
 		};
 	}
 	sanitizeReadToolMessage(message) {
+		const update = this.readToolUpdate(message);
+		if (!update) return message;
+		const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
+		if (!toolCallId) return message;
+		const current = this.mergeToolState(toolCallId, update);
+		this.toolStateById.set(toolCallId, current);
+		return isReadLikeTool(current) ? sanitizeToolMessage(message) : message;
+	}
+	readToolUpdate(message) {
 		const root = asRecord$1(message);
-		if (root?.method !== "session/update") return message;
+		if (root?.method !== "session/update") return;
 		const params = asRecord$1(root.params);
 		const update = asRecord$1(params?.update);
-		if (!params || !update) return message;
+		if (!params || !update) return;
 		const sessionUpdate = update.sessionUpdate;
-		if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") return message;
-		const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : void 0;
-		if (!toolCallId) return message;
+		if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") return;
+		return update;
+	}
+	mergeToolState(toolCallId, update) {
 		const previous = this.toolStateById.get(toolCallId) ?? {};
-		const current = {
+		return {
 			title: typeof update.title === "string" ? update.title : previous.title,
 			kind: typeof update.kind === "string" || update.kind === null ? update.kind : previous.kind
 		};
-		this.toolStateById.set(toolCallId, current);
-		if (!isReadLikeTool(current)) return message;
-		return sanitizeToolMessage(message);
 	}
 	onError(params) {
 		this.stdout.write(`${JSON.stringify(buildJsonRpcErrorResponse({
@@ -3218,15 +3566,16 @@ function parseAuthMethodIdsFromAcpData(data) {
 	const methodIds = [];
 	if (typeof record.methodId === "string" && record.methodId.trim().length > 0) methodIds.push(record.methodId.trim());
 	if (Array.isArray(record.methods)) for (const entry of record.methods) {
-		if (typeof entry === "string" && entry.trim().length > 0) {
-			methodIds.push(entry.trim());
-			continue;
-		}
-		const id = asRecord(entry)?.id;
-		if (typeof id === "string" && id.trim().length > 0) methodIds.push(id.trim());
+		const id = parseAuthMethodIdEntry(entry);
+		if (id) methodIds.push(id);
 	}
 	return dedupeStrings(methodIds);
 }
+function parseAuthMethodIdEntry(entry) {
+	if (typeof entry === "string" && entry.trim().length > 0) return entry.trim();
+	const id = asRecord(entry)?.id;
+	return typeof id === "string" && id.trim().length > 0 ? id.trim() : void 0;
+}
 function renderAuthRequiredHint(params) {
 	const methodIds = dedupeStrings([...parseAuthMethodIdsFromAcpData(params.acp?.data), ...parseAuthMethodIdsFromMessage(params.message)]);
 	if (methodIds.length === 0) return "hint: run `acpx config show` to locate the active config, then add the required credential under `auth` and retry.";
@@ -3236,48 +3585,104 @@ function getTextErrorRemediationHints(params) {
 	const lowerMessage = params.message.toLowerCase();
 	if (params.detailCode === "AUTH_REQUIRED") return [renderAuthRequiredHint(params)];
 	if (params.code === "TIMEOUT") return ["hint: increase `--timeout <seconds>` for long-running prompts, or check whether the agent/provider is stalled."];
-	if (params.code === "NO_SESSION") {
-		if (lowerMessage.includes("create one:")) return [];
-		return ["hint: the saved ACP session is missing or stale; start a fresh session with `acpx <agent> sessions new`, then retry."];
-	}
-	if (lowerMessage.includes("does not support session/load")) return ["hint: this adapter cannot resume saved ACP sessions; create a fresh one with `acpx <agent> sessions new` instead of reusing `--resume-session`."];
-	if (lowerMessage.includes("failed to resume acp session") || lowerMessage.includes("session/load")) return ["hint: rerun with `--verbose` to capture the ACP load failure details.", "hint: if you do not need the old backend session, start a fresh one with `acpx <agent> sessions new` and retry."];
-	if (/\b429\b/u.test(params.message) || lowerMessage.includes("rate limit") || lowerMessage.includes("quota exceeded")) return ["hint: the provider appears rate-limited; retry later, switch model, or check provider quota/billing."];
-	if (lowerMessage.includes("model not found") || lowerMessage.includes("unknown model") || lowerMessage.includes("invalid model")) return ["hint: check the configured model name for this agent, then retry with `--model <model>` or `sessions set-model <model>`."];
-	if (lowerMessage.includes("session/set_mode") || lowerMessage.includes("session/set_model") || lowerMessage.includes("session/set_config_option")) return ["hint: rerun with `--verbose` to capture the ACP method/error details before retrying."];
-	if (params.origin === "acp" && params.code === "RUNTIME" && (params.acp?.code === -32602 || params.acp?.code === -32603 || lowerMessage.includes("internal error"))) return ["hint: rerun with `--verbose` to capture the underlying ACP error details."];
-	return [];
+	if (params.code === "NO_SESSION") return noSessionHints(lowerMessage);
+	return matchingTextErrorRule(params, lowerMessage)?.hints ?? [];
+}
+const TEXT_ERROR_HINT_RULES = [
+	{
+		matches: (_params, lowerMessage) => isUnsupportedSessionLoadError(lowerMessage),
+		hints: ["hint: this adapter cannot resume saved ACP sessions; create a fresh one with `acpx <agent> sessions new` instead of reusing `--resume-session`."]
+	},
+	{
+		matches: (_params, lowerMessage) => isSessionLoadError(lowerMessage),
+		hints: ["hint: rerun with `--verbose` to capture the ACP load failure details.", "hint: if you do not need the old backend session, start a fresh one with `acpx <agent> sessions new` and retry."]
+	},
+	{
+		matches: (params, lowerMessage) => isRateLimitError(params.message, lowerMessage),
+		hints: ["hint: the provider appears rate-limited; retry later, switch model, or check provider quota/billing."]
+	},
+	{
+		matches: (_params, lowerMessage) => isModelLookupError(lowerMessage),
+		hints: ["hint: check the configured model name for this agent, then retry with `--model <model>` or `sessions set-model <model>`."]
+	},
+	{
+		matches: (_params, lowerMessage) => isSessionConfigMethodError(lowerMessage),
+		hints: ["hint: rerun with `--verbose` to capture the ACP method/error details before retrying."]
+	},
+	{
+		matches: isRuntimeAcpProtocolError,
+		hints: ["hint: rerun with `--verbose` to capture the underlying ACP error details."]
+	}
+];
+function matchingTextErrorRule(params, lowerMessage) {
+	return TEXT_ERROR_HINT_RULES.find((rule) => rule.matches(params, lowerMessage));
+}
+function noSessionHints(lowerMessage) {
+	if (lowerMessage.includes("create one:")) return [];
+	return ["hint: the saved ACP session is missing or stale; start a fresh session with `acpx <agent> sessions new`, then retry."];
+}
+function isUnsupportedSessionLoadError(lowerMessage) {
+	return lowerMessage.includes("does not support session/resume") || lowerMessage.includes("does not support session/load");
+}
+function isSessionLoadError(lowerMessage) {
+	return lowerMessage.includes("failed to resume acp session") || lowerMessage.includes("session/resume") || lowerMessage.includes("session/load");
+}
+function isRateLimitError(message, lowerMessage) {
+	return /\b429\b/u.test(message) || ["rate limit", "quota exceeded"].some((text) => lowerMessage.includes(text));
+}
+function isModelLookupError(lowerMessage) {
+	return [
+		"model not found",
+		"unknown model",
+		"invalid model"
+	].some((text) => lowerMessage.includes(text));
+}
+function isSessionConfigMethodError(lowerMessage) {
+	return [
+		"session/set_mode",
+		"session/set_model",
+		"session/set_config_option"
+	].some((text) => lowerMessage.includes(text));
+}
+function isRuntimeAcpProtocolError(params, lowerMessage) {
+	return params.origin === "acp" && params.code === "RUNTIME" && (params.acp?.code === -32602 || params.acp?.code === -32603 || lowerMessage.includes("internal error"));
 }
 function summarizeToolInput(rawInput) {
 	if (rawInput == null) return;
-	if (typeof rawInput === "string" || typeof rawInput === "number" || typeof rawInput === "boolean") return toInline(String(rawInput));
+	if (isScalarToolInput(rawInput)) return toInline(String(rawInput));
 	const record = asRecord(rawInput);
-	if (record) {
-		const command = readFirstString(record, [
-			"command",
-			"cmd",
-			"program"
-		]);
-		const args = readFirstStringArray(record, ["args", "arguments"]);
-		if (command) return toInline([command, ...args ?? []].join(" "));
-		const location = readFirstString(record, [
-			"path",
-			"file",
-			"filePath",
-			"filepath",
-			"target",
-			"uri",
-			"url"
-		]);
-		if (location) return toInline(location);
-		const query = readFirstString(record, [
-			"query",
-			"pattern",
-			"text",
-			"search"
-		]);
-		if (query) return toInline(query);
-	}
+	if (record) return summarizeToolInputRecord(record) ?? summarizeToolInputJson(rawInput);
+	return summarizeToolInputJson(rawInput);
+}
+function isScalarToolInput(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function summarizeToolInputRecord(record) {
+	const command = readFirstString(record, [
+		"command",
+		"cmd",
+		"program"
+	]);
+	const args = readFirstStringArray(record, ["args", "arguments"]);
+	if (command) return toInline([command, ...args ?? []].join(" "));
+	const location = readFirstString(record, [
+		"path",
+		"file",
+		"filePath",
+		"filepath",
+		"target",
+		"uri",
+		"url"
+	]);
+	const query = readFirstString(record, [
+		"query",
+		"pattern",
+		"text",
+		"search"
+	]);
+	return location || query ? toInline(location ?? query ?? "") : void 0;
+}
+function summarizeToolInputJson(rawInput) {
 	const json = safeJson(rawInput, 0);
 	return json ? toInline(json) : void 0;
 }
@@ -3285,10 +3690,8 @@ function formatLocations(locations) {
 	if (!locations || locations.length === 0) return;
 	const unique = /* @__PURE__ */ new Set();
 	for (const location of locations) {
-		const path = location.path?.trim();
-		if (!path) continue;
-		const line = typeof location.line === "number" && Number.isFinite(location.line) ? `:${Math.max(1, Math.trunc(location.line))}` : "";
-		unique.add(`${path}${line}`);
+		const formatted = formatLocation(location);
+		if (formatted) unique.add(formatted);
 	}
 	const items = [...unique];
 	if (items.length === 0) return;
@@ -3297,6 +3700,11 @@ function formatLocations(locations) {
 	if (hidden <= 0) return visible.join(", ");
 	return `${visible.join(", ")}, +${hidden} more`;
 }
+function formatLocation(location) {
+	const path = location.path?.trim();
+	if (!path) return;
+	return `${path}${typeof location.line === "number" && Number.isFinite(location.line) ? `:${Math.max(1, Math.trunc(location.line))}` : ""}`;
+}
 function summarizeDiff(path, oldText, newText) {
 	const oldLines = oldText ? oldText.split("\n").length : 0;
 	const delta = newText.split("\n").length - oldLines;
@@ -3307,64 +3715,74 @@ function textFromContentBlock(content) {
 	switch (content.type) {
 		case "text": return content.text;
 		case "resource_link": return content.title ?? content.name ?? content.uri;
-		case "resource": {
-			if ("text" in content.resource && typeof content.resource.text === "string") return content.resource.text;
-			const uri = content.resource.uri;
-			const mimeType = content.resource.mimeType;
-			return `[resource] ${uri}${mimeType ? ` (${mimeType})` : ""}`;
-		}
+		case "resource": return textFromResourceBlock(content);
 		case "image": return `[image] ${content.mimeType}`;
 		case "audio": return `[audio] ${content.mimeType}`;
 		default: return;
 	}
 }
+function textFromResourceBlock(content) {
+	if ("text" in content.resource && typeof content.resource.text === "string") return content.resource.text;
+	const uri = content.resource.uri;
+	const mimeType = content.resource.mimeType;
+	return `[resource] ${uri}${mimeType ? ` (${mimeType})` : ""}`;
+}
 function summarizeToolContent(content) {
 	if (!content || content.length === 0) return;
 	const fragments = [];
 	for (const entry of content) {
-		if (entry.type === "content") {
-			const text = textFromContentBlock(entry.content);
-			if (text && text.trim()) fragments.push(text.trimEnd());
-			continue;
-		}
-		if (entry.type === "diff") {
-			fragments.push(summarizeDiff(entry.path, entry.oldText, entry.newText));
-			continue;
-		}
-		if (entry.type === "terminal") fragments.push(`[terminal] ${entry.terminalId}`);
+		const fragment = summarizeToolContentEntry(entry);
+		if (fragment) fragments.push(fragment);
 	}
 	const unique = dedupeStrings(fragments.map((fragment) => fragment.trim()).filter((fragment) => fragment.length > 0));
 	if (unique.length === 0) return;
 	return unique.join("\n\n");
 }
+function summarizeToolContentEntry(entry) {
+	if (entry.type === "content") {
+		const text = textFromContentBlock(entry.content);
+		return text && text.trim() ? text.trimEnd() : void 0;
+	}
+	if (entry.type === "diff") return summarizeDiff(entry.path, entry.oldText, entry.newText);
+	if (entry.type === "terminal") return `[terminal] ${entry.terminalId}`;
+}
 function extractOutputText(value, depth = 0, seen = /* @__PURE__ */ new Set()) {
 	if (value == null) return;
+	const scalar = extractScalarOutputText(value);
+	if (scalar !== null) return scalar;
+	if (depth >= 4) return;
+	if (Array.isArray(value)) return extractOutputTextArray(value, depth, seen);
+	return extractOutputTextRecord(value, depth, seen);
+}
+function extractOutputTextRecord(value, depth, seen) {
+	const record = asRecord(value);
+	if (!record || seen.has(record)) return;
+	seen.add(record);
+	return extractPreferredOutputText(record, depth, seen) ?? extractJsonOutputText(record);
+}
+function extractScalarOutputText(value) {
 	if (typeof value === "string") {
 		const trimmed = value.trimEnd();
 		return trimmed.length > 0 ? trimmed : void 0;
 	}
 	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	if (depth >= 4) return;
-	if (Array.isArray(value)) {
-		const parts = value.map((entry) => extractOutputText(entry, depth + 1, seen)).filter((entry) => Boolean(entry));
-		if (parts.length === 0) return;
-		return dedupeStrings(parts).join("\n");
-	}
-	const record = asRecord(value);
-	if (!record) return;
-	if (seen.has(record)) return;
-	seen.add(record);
-	const preferred = [];
-	for (const key of OUTPUT_PRIORITY_KEYS) {
-		if (!(key in record)) continue;
+	return null;
+}
+function extractOutputTextArray(value, depth, seen) {
+	const parts = value.map((entry) => extractOutputText(entry, depth + 1, seen)).filter((entry) => Boolean(entry));
+	return parts.length > 0 ? dedupeStrings(parts).join("\n") : void 0;
+}
+function extractPreferredOutputText(record, depth, seen) {
+	const uniquePreferred = dedupeStrings(OUTPUT_PRIORITY_KEYS.flatMap((key) => {
+		if (!(key in record)) return [];
 		const extracted = extractOutputText(record[key], depth + 1, seen);
-		if (extracted) preferred.push(extracted);
-	}
-	const uniquePreferred = dedupeStrings(preferred);
-	if (uniquePreferred.length > 0) return uniquePreferred.join("\n");
+		return extracted ? [extracted] : [];
+	}));
+	return uniquePreferred.length > 0 ? uniquePreferred.join("\n") : void 0;
+}
+function extractJsonOutputText(record) {
 	const json = safeJson(record, 2);
-	if (!json || json === "{}") return;
-	return json;
+	return !json || json === "{}" ? void 0 : json;
 }
 function summarizeToolOutput(rawOutput, content) {
 	const fragments = dedupeStrings([extractOutputText(rawOutput), summarizeToolContent(content)].map((fragment) => fragment?.trim()).filter((fragment) => Boolean(fragment)));
@@ -3434,6 +3852,9 @@ var TextOutputFormatter = class {
 	renderSessionUpdate(notification) {
 		const update = notification.update;
 		if (update.sessionUpdate !== "agent_thought_chunk") this.flushThoughtBuffer();
+		this.renderSessionUpdateBody(update);
+	}
+	renderSessionUpdateBody(update) {
 		switch (update.sessionUpdate) {
 			case "agent_message_chunk":
 				if (update.content.type === "text") this.writeAssistantChunk(update.content.text);
@@ -3448,13 +3869,16 @@ var TextOutputFormatter = class {
 				this.renderToolUpdate(update);
 				return;
 			case "plan":
-				this.beginSection("plan");
-				this.writeLine(this.bold("[plan]"));
-				for (const entry of update.entries) this.writeLine(`  - [${entry.status}] ${entry.content}`);
+				this.renderPlanUpdate(update.entries);
 				return;
 			default: return;
 		}
 	}
+	renderPlanUpdate(entries) {
+		this.beginSection("plan");
+		this.writeLine(this.bold("[plan]"));
+		for (const entry of entries) this.writeLine(`  - [${entry.status}] ${entry.content}`);
+	}
 	renderDone(stopReason) {
 		this.flushThoughtBuffer();
 		this.beginSection("done");
@@ -3551,7 +3975,13 @@ var TextOutputFormatter = class {
 		return created;
 	}
 	mergeToolState(state, update) {
-		if (typeof update.title === "string" && update.title.trim().length > 0) state.title = update.title;
+		this.mergeToolTitle(state, update.title);
+		this.mergeToolPayloadState(state, update);
+	}
+	mergeToolTitle(state, title) {
+		if (typeof title === "string" && title.trim().length > 0) state.title = title;
+	}
+	mergeToolPayloadState(state, update) {
 		if (update.status !== void 0) state.status = update.status;
 		if (update.kind !== void 0) state.kind = update.kind;
 		if (update.locations !== void 0) state.locations = update.locations;
@@ -3681,8 +4111,8 @@ var QuietOutputFormatter = class {
 		return parts.length > 0 ? `[acpx] tokens: ${parts.join(" ")}` : void 0;
 	}
 	formatCostLine(cost) {
-		if (typeof cost === "number" && Number.isFinite(cost)) return `[acpx] cost: ${formatMetadataNumber(cost)}`;
-		if (typeof cost === "string" && cost.trim()) return `[acpx] cost: ${cost.trim()}`;
+		const scalar = this.formatScalarCostLine(cost);
+		if (scalar) return scalar;
 		const record = asRecord(cost);
 		if (!record) return;
 		const amount = readFirstFiniteNumber(record, [
@@ -3694,6 +4124,10 @@ var QuietOutputFormatter = class {
 		const currency = typeof record.currency === "string" && record.currency.trim() ? ` ${record.currency.trim()}` : "";
 		return `[acpx] cost: ${formatMetadataNumber(amount)}${currency}`;
 	}
+	formatScalarCostLine(cost) {
+		if (typeof cost === "number" && Number.isFinite(cost)) return `[acpx] cost: ${formatMetadataNumber(cost)}`;
+		if (typeof cost === "string" && cost.trim()) return `[acpx] cost: ${cost.trim()}`;
+	}
 };
 function createOutputFormatter(format, options = {}) {
 	const stdout = options.stdout ?? process.stdout;
@@ -3709,4 +4143,4 @@ function createOutputFormatter(format, options = {}) {
 //#endregion
 export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as h, session_exports as i, flushPerfMetricsCapture as l, DEFAULT_QUEUE_OWNER_TTL_MS as m, getTextErrorRemediationHints as n, runOnce as o, probeQueueOwnerHealth as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, installPerfMetricsCapture as u };
 
-//# sourceMappingURL=output-BL9XRWzS.js.map
+//# sourceMappingURL=output-DPg20dvn.js.map