acpx 0.15.0 → 0.16.0

package/dist/{output-CIVecnHU.js → output-uo5a27KB.js}

@@ -1,11 +1,15 @@
-import { $ as formatPerfMetric, B as absolutePath, Bt as extractAcpError, C as sessionOptionsFromRecord, D as AcpClient, Dt as TimeoutError, Et as InterruptedError, F as runTimedExecFile, G as listSessions, H as findSession, Ht as toAcpErrorPayload, I as splitCommandLine, J as pruneSessions, K as listSessionsForAgent, Kt as OUTPUT_ERROR_CODES, Lt as formatErrorMessage, M as modelStateFromConfigOptions, Ot as withInterrupt, Rt as isRetryablePromptError, S as persistSessionOptions, T as applyLifecycleSnapshotToRecord, Tt as textPrompt, U as findSessionByDirectoryWalk, V as findGitRepositoryRoot, W as isoNow, X as writeSessionRecord, Y as resolveSessionRecord, _ as recordPromptSubmission, _t as isAcpJsonRpcMessage, a as applyConfigOptionSelection, at as setPerfGauge, b as advertisedModelState, c as applyRequestedModelIfAdvertised, d as setDesiredModeId, dt as defaultSessionEventLog, en as QueueConnectionError, et as getPerfMetricsSnapshot, f as syncAdvertisedModelState, ft as sessionBaseDir, g as recordClientOperation, gt as extractSessionUpdateNotification, h as createSessionConversation, ht as sessionEventSegmentPath, i as connectAndLoadSession, it as resetPerfMetrics, kt as withTimeout, l as currentModelIdFromSetModelResponse, lt as normalizeRuntimeSessionId, m as cloneSessionConversation, mt as sessionEventLockPath, n as runPromptTurn, nt as measurePerf, o as applyConfigOptionsToRecord, ot as startPerfTimer, p as cloneSessionAcpxState, pt as sessionEventActivePath, q as normalizeName, qt as OUTPUT_ERROR_ORIGINS, r as withConnectedSession, rt as recordPerfDuration, s as applyModelSelection, t as LiveSessionCheckpoint, tn as QueueProtocolError, tt as incrementPerfCounter, u as setCurrentModelId, v as recordSessionUpdate, vt as parseJsonRpcErrorMessage, w as applyConversation, wt as promptToDisplayText, x as mergeSessionOptions, xt as isPromptInput, y as trimConversationForRuntime, yt as parsePromptStopReason, zt as normalizeOutputError } from "./live-checkpoint-CYRs-D9t.js";
-import fs, { mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { $ as getPerfMetricsSnapshot, At as isRetryablePromptError, B as absolutePath, C as recordSessionUpdate, Dt as withTimeout, E as AcpClient, Et as withInterrupt, G as listSessions, H as findSession, I as promptToDisplayText, J as pruneSessions, K as listSessionsForAgent, Kt as QueueConnectionError, L as textPrompt, Mt as extractAcpError, N as isPromptInput, Pt as toAcpErrorPayload, Q as formatPerfMetric, Rt as OUTPUT_ERROR_CODES, S as recordPromptSubmission, St as parsePromptStopReason, T as advertisedModelState, Tt as TimeoutError, U as findSessionByDirectoryWalk, V as findGitRepositoryRoot, W as isoNow, X as writeSessionRecord, Y as resolveSessionRecord, _t as isProcessAlive, a as applyConfigOptionSelection, at as startPerfTimer, bt as parseJsonRpcErrorMessage, c as applyModelSelection, ct as normalizeAgentSessionId, d as mergeSessionOptions, dt as sessionBaseDir, et as incrementPerfCounter, f as persistSessionOptions, ft as sessionEventActivePath, g as createInitialSessionRecord, h as applyLifecycleSnapshotToRecord, i as connectAndLoadSession, it as setPerfGauge, jt as normalizeOutputError, kt as formatErrorMessage, l as applyRequestedModelIfAdvertised, m as applyConversation, mt as sessionEventSegmentPath, n as runPromptTurn, nt as recordPerfDuration, o as applyConfigOptionsToRecord, p as sessionOptionsFromRecord, pt as sessionEventLockPath, q as normalizeName, qt as QueueProtocolError, r as withConnectedSession, rt as resetPerfMetrics, s as applyInitialModelSelection, t as LiveSessionCheckpoint, tt as measurePerf, u as setDesiredModeId, v as cloneSessionAcpxState, vt as extractSessionUpdateNotification, w as trimConversationForRuntime, wt as InterruptedError, x as recordClientOperation, xt as parsePermissionNotice, y as cloneSessionConversation, yt as isAcpJsonRpcMessage, zt as OUTPUT_ERROR_ORIGINS } from "./live-checkpoint-BEfxBKCh.js";
+import { M as runTimedExecFile, N as splitCommandLine } from "./agent-registry-DU6mhZBL.js";
+import fs, { realpathSync } from "node:fs";
 import path from "node:path";
+import { spawn } from "node:child_process";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
+import { appendRegularFile, appendRegularFileSync, withTempFile } from "@openclaw/fs-safe/advanced";
 import { createHash, randomInt, randomUUID } from "node:crypto";
-import { spawn } from "node:child_process";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
 import net from "node:net";
+import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -18,17 +22,6 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#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/session/contracts.ts
 const DEFAULT_QUEUE_OWNER_TTL_MS = 3e5;
 function normalizeQueueOwnerTtlMs(ttlMs) {
@@ -61,7 +54,7 @@ function queueSocketPath(sessionId, homeDir = os.homedir()) {
 }
 //#endregion
 //#region src/cli/queue/lease-store.ts
-const PROCESS_SIGTERM_GRACE_MS = 4e3;
+const PROCESS_SIGTERM_GRACE_MS = process.platform === "win32" ? 4e3 : 12e3;
 const PROCESS_SIGKILL_GRACE_MS = 1500;
 const PROCESS_POLL_MS = 50;
 const QUEUE_OWNER_STALE_HEARTBEAT_MS = 15e3;
@@ -141,61 +134,62 @@ async function waitForProcessExit(pid, timeoutMs) {
 	}
 	return !isProcessAlive(pid);
 }
-async function cleanupStaleQueueOwner(sessionId, owner) {
-	const lockPath = queueLockFilePath(sessionId);
-	await removeSocketFile(owner?.socketPath ?? queueSocketPath(sessionId)).catch(() => {});
-	await fs$1.unlink(lockPath).catch((error) => {
+async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+	if (!await isCurrent()) return;
+	await removeSocketFile(socketPath).catch(() => {});
+	if (!await isCurrent()) return;
+	await fs$1.unlink(queueLockFilePath(sessionId)).catch((error) => {
 		if (error.code !== "ENOENT") throw error;
 	});
 }
-async function retireStaleQueueOwner(sessionId, owner) {
-	if (owner && isProcessAlive(owner.pid)) await terminateProcess(owner.pid);
-	await cleanupStaleQueueOwner(sessionId, owner);
+async function ownsQueueLease(owner, requireStale = false) {
+	const current = await readQueueOwnerRecord(owner.sessionId);
+	return current?.pid === owner.pid && current.ownerGeneration === owner.ownerGeneration && current.sessionId === owner.sessionId && (!requireStale || !ownerIsAlive(current) || isQueueOwnerHeartbeatStale(current));
+}
+function ownerIsAlive(owner) {
+	return owner.pid === process.pid || isProcessAlive(owner.pid);
 }
 async function readQueueOwnerRecord(sessionId) {
 	const lockPath = queueLockFilePath(sessionId);
 	try {
 		const payload = await fs$1.readFile(lockPath, "utf8");
-		return parseQueueOwnerRecord(JSON.parse(payload)) ?? void 0;
+		const parsed = parseQueueOwnerRecord(JSON.parse(payload));
+		return parsed?.sessionId === sessionId ? parsed : void 0;
 	} catch {
 		return;
 	}
 }
-async function terminateProcess(pid) {
+async function terminateProcess(pid, beforeSignal) {
 	if (!isProcessAlive(pid)) return false;
-	try {
-		process.kill(pid, "SIGTERM");
-	} catch {
-		return false;
-	}
-	if (await waitForProcessExit(pid, PROCESS_SIGTERM_GRACE_MS)) return true;
-	try {
-		process.kill(pid, "SIGKILL");
-	} catch {
-		return false;
+	for (const [signal, graceMs] of [["SIGTERM", PROCESS_SIGTERM_GRACE_MS], ["SIGKILL", PROCESS_SIGKILL_GRACE_MS]]) {
+		if (beforeSignal && !await beforeSignal(signal)) return false;
+		try {
+			process.kill(pid, signal);
+		} catch {
+			return false;
+		}
+		if (await waitForProcessExit(pid, graceMs)) return true;
 	}
-	await waitForProcessExit(pid, PROCESS_SIGKILL_GRACE_MS);
-	return true;
-}
-async function ensureOwnerIsUsable(sessionId, owner) {
-	const alive = isProcessAlive(owner.pid);
-	const stale = isQueueOwnerHeartbeatStale(owner);
-	if (alive && !stale) return true;
-	await retireStaleQueueOwner(sessionId, owner);
 	return false;
 }
+async function resolveUsableQueueOwner(sessionId, owner) {
+	if (ownerIsAlive(owner) && !isQueueOwnerHeartbeatStale(owner)) return owner;
+	await terminateQueueOwnerForSession(sessionId, owner, true);
+	const current = await readQueueOwnerRecord(sessionId);
+	return current?.pid === owner.pid && current.ownerGeneration === owner.ownerGeneration && ownerIsAlive(current) && !isQueueOwnerHeartbeatStale(current) ? current : void 0;
+}
 async function readQueueOwnerStatus(sessionId) {
-	const owner = await readQueueOwnerRecord(sessionId);
+	const observed = await readQueueOwnerRecord(sessionId);
+	if (!observed) return;
+	const owner = await resolveUsableQueueOwner(sessionId, observed);
 	if (!owner) return;
-	const alive = await ensureOwnerIsUsable(sessionId, owner);
-	if (!alive) return;
 	return {
 		pid: owner.pid,
 		socketPath: owner.socketPath,
 		heartbeatAt: owner.heartbeatAt,
 		ownerGeneration: owner.ownerGeneration,
 		queueDepth: owner.queueDepth,
-		alive,
+		alive: true,
 		stale: isQueueOwnerHeartbeatStale(owner)
 	};
 }
@@ -207,30 +201,32 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 	const socketPath = queueSocketPath(sessionId);
 	const createdAt = clock();
 	const ownerGeneration = createOwnerGeneration();
-	const payload = JSON.stringify({
+	const lease = {
 		pid: process.pid,
 		sessionId,
+		lockPath,
 		socketPath,
 		createdAt,
-		heartbeatAt: createdAt,
 		ownerGeneration,
-		queueDepth: 0,
-		...mcpConfigMetadata
-	}, null, 2);
+		...mcpConfigMetadata,
+		updates: Promise.resolve(),
+		released: false
+	};
 	try {
-		await fs$1.writeFile(lockPath, `${payload}\n`, {
-			encoding: "utf8",
-			flag: "wx"
+		await stageQueueOwnerRecord(lease, 0, () => createdAt, async (tempPath, payload) => {
+			try {
+				await fs$1.link(tempPath, lockPath);
+			} catch (error) {
+				if (!isHardlinkFallbackError(error)) throw error;
+				await fs$1.writeFile(lockPath, payload, {
+					encoding: "utf8",
+					flag: "wx",
+					mode: 384
+				});
+			}
 		});
 		await removeSocketFile(socketPath).catch(() => {});
-		return {
-			sessionId,
-			lockPath,
-			socketPath,
-			createdAt,
-			ownerGeneration,
-			...mcpConfigMetadata
-		};
+		return lease;
 	} catch (error) {
 		return await handleLeaseCollision(sessionId, error);
 	}
@@ -248,10 +244,25 @@ async function handleLeaseCollision(sessionId, error) {
 	if (error.code !== "EEXIST") throw error;
 	const owner = await readQueueOwnerRecord(sessionId);
 	if (!owner) {
-		await cleanupStaleQueueOwner(sessionId, owner);
+		await cleanupAbandonedReservation(sessionId);
 		return;
 	}
-	if (!isProcessAlive(owner.pid) || isQueueOwnerHeartbeatStale(owner)) await retireStaleQueueOwner(sessionId, owner);
+	await resolveUsableQueueOwner(sessionId, owner);
+}
+async function cleanupAbandonedReservation(sessionId) {
+	const lockPath = queueLockFilePath(sessionId);
+	try {
+		const observed = await fs$1.lstat(lockPath, { bigint: true });
+		if (!observed.isFile() || Date.now() - Number(observed.mtimeMs) <= QUEUE_OWNER_STALE_HEARTBEAT_MS) return;
+		const raw = await fs$1.readFile(lockPath, "utf8");
+		if (await readQueueOwnerRecord(sessionId)) return;
+		await cleanupQueueOwnerFiles(sessionId, queueSocketPath(sessionId), async () => {
+			const current = await fs$1.lstat(lockPath, { bigint: true });
+			return current.isFile() && current.dev === observed.dev && current.ino === observed.ino && current.mtimeNs === observed.mtimeNs && await fs$1.readFile(lockPath, "utf8") === raw;
+		});
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
 }
 function resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory) {
 	if (typeof mcpConfigOrNowIsoFactory === "string") return {
@@ -271,31 +282,52 @@ function resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory) {
 		clock: nowIsoFactory
 	};
 }
-async function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
+function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
+	if (lease.released) return Promise.resolve();
+	const update = lease.updates.then(async () => {
+		await stageQueueOwnerRecord(lease, options.queueDepth, nowIsoFactory, async (tempPath) => {
+			if (await ownsQueueLease(lease)) await fs$1.rename(tempPath, lease.lockPath);
+		});
+	});
+	lease.updates = update.catch(() => {});
+	return update;
+}
+async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 	const payload = JSON.stringify({
 		pid: process.pid,
 		sessionId: lease.sessionId,
 		socketPath: lease.socketPath,
 		createdAt: lease.createdAt,
-		heartbeatAt: nowIsoFactory(),
+		heartbeatAt: clock(),
 		ownerGeneration: lease.ownerGeneration,
-		queueDepth: Math.max(0, Math.round(options.queueDepth)),
+		queueDepth: Math.max(0, Math.round(queueDepth)),
 		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
 		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
 	}, null, 2);
-	await fs$1.writeFile(lease.lockPath, `${payload}\n`, { encoding: "utf8" });
+	await withTempFile({
+		rootDir: path.dirname(lease.lockPath),
+		prefix: "owner",
+		fileName: "lease"
+	}, async (tempPath) => {
+		await fs$1.writeFile(tempPath, `${payload}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		await publish(tempPath, `${payload}\n`);
+	});
 }
 async function releaseQueueOwnerLease(lease) {
-	await removeSocketFile(lease.socketPath).catch(() => {});
-	await fs$1.unlink(lease.lockPath).catch((error) => {
-		if (error.code !== "ENOENT") throw error;
-	});
+	lease.released = true;
+	await lease.updates;
+	await cleanupQueueOwnerFiles(lease.sessionId, lease.socketPath, () => ownsQueueLease(lease));
 }
-async function terminateQueueOwnerForSession(sessionId) {
-	const owner = await readQueueOwnerRecord(sessionId);
-	if (!owner) return;
-	if (isProcessAlive(owner.pid)) await terminateProcess(owner.pid);
-	await cleanupStaleQueueOwner(sessionId, owner);
+async function terminateQueueOwnerForSession(sessionId, expectedOwner, requireStale = false) {
+	const owner = expectedOwner ?? await readQueueOwnerRecord(sessionId);
+	if (!owner || owner.sessionId !== sessionId) return;
+	if (ownerIsAlive(owner)) await terminateProcess(owner.pid, (signal) => ownsQueueLease(owner, requireStale && signal === "SIGTERM"));
+	if (ownerIsAlive(owner)) return;
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner));
 }
 async function waitMs(ms) {
 	await new Promise((resolve) => {
@@ -339,16 +371,13 @@ async function connectToSocket(socketPath, timeoutMs = SOCKET_CONNECTION_TIMEOUT
 	});
 }
 async function connectToQueueOwner(owner, maxAttempts = QUEUE_CONNECT_ATTEMPTS) {
-	let lastError;
 	const attempts = Math.max(1, Math.trunc(maxAttempts));
 	for (let attempt = 0; attempt < attempts; attempt += 1) try {
 		return await measurePerf("queue.connect", async () => await connectToSocket(owner.socketPath));
 	} catch (error) {
-		lastError = error;
 		if (!shouldRetryQueueConnect(error)) throw error;
 		await waitMs(50);
 	}
-	if (lastError && !shouldRetryQueueConnect(lastError)) throw lastError;
 }
 //#endregion
 //#region src/cli/queue/ipc-health.ts
@@ -1151,7 +1180,7 @@ async function maybeRecoverStaleOwnerAfterProtocolMismatch(params) {
 	if (!(params.error instanceof QueueProtocolError)) return false;
 	const detailCode = params.error.detailCode;
 	if (!detailCode || !STALE_OWNER_PROTOCOL_DETAIL_CODES.has(detailCode)) return false;
-	await terminateQueueOwnerForSession(params.sessionId).catch(() => {});
+	await terminateQueueOwnerForSession(params.sessionId, params.owner).catch(() => {});
 	incrementPerfCounter("queue.owner.stale_recovered");
 	if (params.verbose) process.stderr.write(`[acpx] dropped stale queue owner metadata after protocol mismatch for session ${params.sessionId} (${detailCode})\n`);
 	return true;
@@ -1390,29 +1419,15 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
 		request,
 		onMessage: (message, { state, resolve, reject }) => {
 			if (message.type === "error") {
-				reject(new QueueConnectionError(message.message, {
-					outputCode: message.code,
-					detailCode: message.detailCode,
-					origin: message.origin ?? "queue",
-					retryable: message.retryable,
-					acp: message.acp
-				}));
+				reject(queueConnectionErrorFromOwner(message, false));
 				return;
 			}
 			if (!state.acknowledged) {
-				reject(new QueueConnectionError("Queue owner did not acknowledge request", {
-					detailCode: "QUEUE_ACK_MISSING",
-					origin: "queue",
-					retryable: true
-				}));
+				reject(missingQueueAckError());
 				return;
 			}
 			if (!isExpectedResponse(message)) {
-				reject(new QueueProtocolError("Queue owner returned unexpected response", {
-					detailCode: "QUEUE_PROTOCOL_UNEXPECTED_RESPONSE",
-					origin: "queue",
-					retryable: true
-				}));
+				reject(unexpectedQueueResponseError());
 				return;
 			}
 			resolve(message);
@@ -1435,87 +1450,47 @@ async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
 	});
 }
 async function submitCancelToQueueOwner(owner) {
-	const request = {
+	return (await submitControlToQueueOwner(owner, {
 		type: "cancel_prompt",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration
-	};
-	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "cancel_result");
-	if (!response) return;
-	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched cancel response", {
-		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-		origin: "queue",
-		retryable: true
-	});
-	return response.cancelled;
+	}, (message) => message.type === "cancel_result"))?.cancelled;
 }
 async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
-	const request = {
+	return await submitControlToQueueOwner(owner, {
 		type: "set_mode",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		modeId,
 		timeoutMs
-	};
-	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_mode_result");
-	if (!response) return;
-	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_mode response", {
-		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-		origin: "queue",
-		retryable: true
-	});
-	return true;
+	}, (message) => message.type === "set_mode_result") ? true : void 0;
 }
 async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
-	const request = {
+	return await submitControlToQueueOwner(owner, {
 		type: "set_model",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		modelId,
 		timeoutMs
-	};
-	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_model_result");
-	if (!response) return;
-	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_model response", {
-		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-		origin: "queue",
-		retryable: true
-	});
-	return response;
+	}, (message) => message.type === "set_model_result");
 }
 async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
-	const request = {
+	return (await submitControlToQueueOwner(owner, {
 		type: "set_config_option",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		configId,
 		value,
 		timeoutMs
-	};
-	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "set_config_option_result");
-	if (!response) return;
-	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched set_config_option response", {
-		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-		origin: "queue",
-		retryable: true
-	});
-	return response.response;
+	}, (message) => message.type === "set_config_option_result"))?.response;
 }
 async function submitCloseSessionToQueueOwner(owner, timeoutMs) {
-	const request = {
+	return (await submitControlToQueueOwner(owner, {
 		type: "close_session",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		timeoutMs
-	};
-	const response = await submitControlToQueueOwner(owner, request, (message) => message.type === "close_session_result");
-	if (!response) return;
-	if (response.requestId !== request.requestId) throw new QueueProtocolError("Queue owner returned mismatched close_session response", {
-		detailCode: "QUEUE_PROTOCOL_MALFORMED_MESSAGE",
-		origin: "queue",
-		retryable: true
-	});
-	return response.closed;
+	}, (message) => message.type === "close_session_result"))?.closed;
 }
 function queueOwnerMcpConfigMatches(owner, options) {
 	return owner.mcpConfigPath === options.mcpConfigPath && owner.mcpConfigFingerprint === options.mcpConfigFingerprint;
@@ -1529,9 +1504,10 @@ function assertQueueOwnerMcpConfigMatches(owner, options) {
 	});
 }
 async function trySubmitToRunningOwner(options) {
-	const owner = await readQueueOwnerRecord(options.sessionId);
+	const observed = await readQueueOwnerRecord(options.sessionId);
+	if (!observed) return;
+	const owner = await resolveUsableQueueOwner(options.sessionId, observed);
 	if (!owner) return;
-	if (!await ensureOwnerIsUsable(options.sessionId, owner)) return;
 	assertQueueOwnerMcpConfigMatches(owner, options);
 	let submitted;
 	try {
@@ -1556,78 +1532,64 @@ async function trySubmitToRunningOwner(options) {
 		retryable: true
 	});
 }
-async function tryCloseSessionOnRunningOwner(options) {
+async function tryControlOnRunningOwner(options) {
 	const owner = await readQueueOwnerRecord(options.sessionId);
 	if (!owner) return;
-	const closed = await submitCloseSessionToQueueOwner(owner, options.timeoutMs);
-	if (closed !== void 0) {
-		if (options.verbose) process.stderr.write(`[acpx] requested session/close on active owner pid ${owner.pid} for session ${options.sessionId}\n`);
-		return closed;
+	const response = await options.submit(owner);
+	if (response !== void 0) {
+		if (options.verbose) process.stderr.write(`${options.logPrefix} ${owner.pid} for session ${options.sessionId}\n`);
+		return response;
 	}
 	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
-	throw new QueueConnectionError("Session queue owner is running but not accepting close_session requests", {
+	throw new QueueConnectionError(`Session queue owner is running but not accepting ${options.requestName} requests`, {
 		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
 		origin: "queue",
 		retryable: true
 	});
 }
+async function tryCloseSessionOnRunningOwner(options) {
+	return await tryControlOnRunningOwner({
+		sessionId: options.sessionId,
+		verbose: options.verbose,
+		requestName: "close_session",
+		logPrefix: "[acpx] requested session/close on active owner pid",
+		submit: (owner) => submitCloseSessionToQueueOwner(owner, options.timeoutMs)
+	});
+}
 async function tryCancelOnRunningOwner(options) {
-	const owner = await readQueueOwnerRecord(options.sessionId);
-	if (!owner) return;
-	const cancelled = await submitCancelToQueueOwner(owner);
-	if (cancelled !== void 0) {
-		if (options.verbose) process.stderr.write(`[acpx] requested cancel on active owner pid ${owner.pid} for session ${options.sessionId}\n`);
-		return cancelled;
-	}
-	if (!(await probeQueueOwnerHealth(options.sessionId)).hasLease) return;
-	throw new QueueConnectionError("Session queue owner is running but not accepting cancel requests", {
-		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-		origin: "queue",
-		retryable: true
+	return await tryControlOnRunningOwner({
+		sessionId: options.sessionId,
+		verbose: options.verbose,
+		requestName: "cancel",
+		logPrefix: "[acpx] requested cancel on active owner pid",
+		submit: submitCancelToQueueOwner
 	});
 }
 async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
-	const owner = await readQueueOwnerRecord(sessionId);
-	if (!owner) return;
-	if (await submitSetModeToQueueOwner(owner, modeId, timeoutMs)) {
-		if (verbose) process.stderr.write(`[acpx] requested session/set_mode on owner pid ${owner.pid} for session ${sessionId}\n`);
-		return true;
-	}
-	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
-	throw new QueueConnectionError("Session queue owner is running but not accepting set_mode requests", {
-		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-		origin: "queue",
-		retryable: true
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_mode",
+		logPrefix: "[acpx] requested session/set_mode on owner pid",
+		submit: (owner) => submitSetModeToQueueOwner(owner, modeId, timeoutMs)
 	});
 }
 async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
-	const owner = await readQueueOwnerRecord(sessionId);
-	if (!owner) return;
-	const submitted = await submitSetModelToQueueOwner(owner, modelId, timeoutMs);
-	if (submitted) {
-		if (verbose) process.stderr.write(`[acpx] requested a model config update on owner pid ${owner.pid} for session ${sessionId}\n`);
-		return submitted;
-	}
-	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
-	throw new QueueConnectionError("Session queue owner is running but not accepting set_model requests", {
-		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-		origin: "queue",
-		retryable: true
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_model",
+		logPrefix: "[acpx] requested a model config update on owner pid",
+		submit: (owner) => submitSetModelToQueueOwner(owner, modelId, timeoutMs)
 	});
 }
 async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
-	const owner = await readQueueOwnerRecord(sessionId);
-	if (!owner) return;
-	const response = await submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs);
-	if (response) {
-		if (verbose) process.stderr.write(`[acpx] requested session/set_config_option on owner pid ${owner.pid} for session ${sessionId}\n`);
-		return response;
-	}
-	if (!(await probeQueueOwnerHealth(sessionId)).hasLease) return;
-	throw new QueueConnectionError("Session queue owner is running but not accepting set_config_option requests", {
-		detailCode: "QUEUE_NOT_ACCEPTING_REQUESTS",
-		origin: "queue",
-		retryable: true
+	return await tryControlOnRunningOwner({
+		sessionId,
+		verbose,
+		requestName: "set_config_option",
+		logPrefix: "[acpx] requested session/set_config_option on owner pid",
+		submit: (owner) => submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs)
 	});
 }
 //#endregion
@@ -1864,41 +1826,28 @@ async function createSessionRecordWithClient(client, options) {
 	const createdState = options.resumeSessionId ? await resumeSessionRecordWithClient(client, options, cwd) : await createFreshSessionState(client, options, cwd);
 	const { sessionId, agentSessionId } = createdState;
 	const lifecycle = client.getAgentLifecycleSnapshot();
-	const now = isoNow();
 	const record = {
-		schema: "acpx.session.v1",
-		acpxRecordId: sessionId,
-		acpSessionId: sessionId,
-		agentSessionId,
-		agentCommand: options.agentCommand,
-		agentArgv: options.agentArgv,
-		cwd,
-		name: normalizeName(options.name),
-		createdAt: now,
-		lastUsedAt: now,
-		lastSeq: 0,
+		...createInitialSessionRecord({
+			recordId: sessionId,
+			sessionId,
+			agentSessionId,
+			agentCommand: options.agentCommand,
+			agentArgv: options.agentArgv,
+			cwd,
+			name: normalizeName(options.name)
+		}),
 		lastRequestId: void 0,
-		eventLog: defaultSessionEventLog(sessionId),
-		closed: false,
-		closedAt: void 0,
 		pid: lifecycle.running ? lifecycle.pid : void 0,
 		agentStartedAt: lifecycle.startedAt,
 		protocolVersion: client.initializeResult?.protocolVersion,
-		agentCapabilities: client.initializeResult?.agentCapabilities,
-		...createSessionConversation(now),
-		acpx: {}
+		agentCapabilities: client.initializeResult?.agentCapabilities
 	};
 	persistSessionOptions(record, options.sessionOptions);
-	applyCreatedSessionModelState(record, createdState, options.sessionOptions?.model);
+	applyConfigOptionsToRecord(record, createdState.sessionResult);
+	applyInitialModelSelection(record, createdState.sessionResult.models, options.sessionOptions?.model, createdState.modelApplication);
 	await writeSessionRecord(record);
 	return record;
 }
-function applyCreatedSessionModelState(record, state, requestedModel) {
-	applyConfigOptionsToRecord(record, state.sessionResult);
-	applyConfigOptionsToRecord(record, state.requestedModelResponse);
-	syncAdvertisedModelState(record, state.requestedModelResponse ? modelStateFromConfigOptions(state.requestedModelResponse.configOptions) : state.sessionModels);
-	if (state.requestedModelApplied) setCurrentModelId(record, currentModelIdFromSetModelResponse(state.requestedModelResponse, requestedModel));
-}
 async function createFreshSessionState(client, options, cwd) {
 	const createdSession = await withTimeout(client.createSession(cwd), options.timeoutMs);
 	const modelApplication = await applyRequestedModelIfAdvertised({
@@ -1912,11 +1861,9 @@ async function createFreshSessionState(client, options, cwd) {
 	});
 	return {
 		sessionId: createdSession.sessionId,
-		agentSessionId: normalizeRuntimeSessionId(createdSession.agentSessionId),
+		agentSessionId: normalizeAgentSessionId(createdSession.agentSessionId),
 		sessionResult: createdSession,
-		sessionModels: createdSession.models,
-		requestedModelApplied: modelApplication.applied,
-		requestedModelResponse: modelApplication.response
+		modelApplication
 	};
 }
 async function resumeSessionRecordWithClient(client, options, cwd) {
@@ -1937,11 +1884,9 @@ async function resumeSessionRecordWithClient(client, options, cwd) {
 		});
 		return {
 			sessionId: options.resumeSessionId,
-			agentSessionId: normalizeRuntimeSessionId(resumedSession.agentSessionId),
+			agentSessionId: normalizeAgentSessionId(resumedSession.agentSessionId),
 			sessionResult: resumedSession,
-			sessionModels,
-			requestedModelApplied: modelApplication.applied,
-			requestedModelResponse: modelApplication.response
+			modelApplication
 		};
 	} catch (error) {
 		throw new Error(`Failed to resume ACP session ${options.resumeSessionId}: ${formatErrorMessage(error)}`, { cause: error });
@@ -2113,7 +2058,11 @@ function payloadHasMetrics(payload) {
 }
 function appendPerfMetricsPayload(payload) {
 	fs.mkdirSync(path.dirname(captureFilePath), { recursive: true });
-	fs.appendFileSync(captureFilePath, `${JSON.stringify(payload)}\n`, "utf8");
+	appendRegularFileSync({
+		filePath: captureFilePath,
+		content: `${JSON.stringify(payload)}\n`,
+		mode: 384
+	});
 	captureSequence += 1;
 }
 function writePerfMetricsCapture(reason, resetAfterWrite) {
@@ -2166,6 +2115,7 @@ var QueueOwnerTurnController = class {
 	state = "idle";
 	pendingCancel = false;
 	activeController;
+	waitingTurn;
 	constructor(options) {
 		this.options = options;
 	}
@@ -2178,6 +2128,8 @@ var QueueOwnerTurnController = class {
 	beginTurn() {
 		this.state = "starting";
 		this.pendingCancel = false;
+		this.waitingTurn = new AbortController();
+		return this.waitingTurn.signal;
 	}
 	markPromptActive() {
 		if (this.state === "starting" || this.state === "active") this.state = "active";
@@ -2185,6 +2137,7 @@ var QueueOwnerTurnController = class {
 	endTurn() {
 		this.state = "idle";
 		this.pendingCancel = false;
+		this.waitingTurn = void 0;
 	}
 	beginClosing() {
 		this.state = "closing";
@@ -2213,6 +2166,7 @@ var QueueOwnerTurnController = class {
 		}
 		if (this.state === "starting" || this.state === "active") {
 			this.pendingCancel = true;
+			this.waitingTurn?.abort();
 			return true;
 		}
 		return false;
@@ -2248,8 +2202,6 @@ var QueueOwnerTurnController = class {
 };
 //#endregion
 //#region src/cli/session/queue-owner-process.ts
-const QUEUE_OWNER_PAYLOAD_FILE_ENV = "ACPX_QUEUE_OWNER_PAYLOAD_FILE";
-const QUEUE_OWNER_PAYLOAD_ENV = "ACPX_QUEUE_OWNER_PAYLOAD";
 function isNonEmptyStringArray(value) {
 	return Array.isArray(value) && value.length > 0 && value.every((entry) => typeof entry === "string" && entry.length > 0);
 }
@@ -2341,35 +2293,8 @@ function queueOwnerRuntimeOptionsFromSend(options) {
 		sessionOptions: options.sessionOptions
 	};
 }
-function writeQueueOwnerPayloadFile(payload) {
-	const dir = mkdtempSync(path.join(os.tmpdir(), "acpx-queue-owner-"));
-	const payloadPath = path.join(dir, "payload.json");
-	writeFileSync(payloadPath, payload, {
-		encoding: "utf8",
-		flag: "wx",
-		mode: 384
-	});
-	return payloadPath;
-}
 /** Max stderr bytes retained for cold-start diagnostics. */
 const QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES = 4e3;
-function buildQueueOwnerSpawnOptions(payloadFilePath, opts) {
-	const env = {
-		...process.env,
-		[QUEUE_OWNER_PAYLOAD_FILE_ENV]: payloadFilePath
-	};
-	delete env[QUEUE_OWNER_PAYLOAD_ENV];
-	return {
-		detached: true,
-		stdio: opts?.captureStderr === true ? [
-			"ignore",
-			"ignore",
-			"pipe"
-		] : "ignore",
-		env,
-		windowsHide: true
-	};
-}
 function formatQueueOwnerStartupFailure(params) {
 	const parts = [`Session queue owner failed to start for session ${params.sessionId}`];
 	if (params.exit.spawnError) parts.push(`spawn error: ${params.exit.spawnError.message}`);
@@ -2378,19 +2303,33 @@ function formatQueueOwnerStartupFailure(params) {
 		const signalPart = params.exit.signal ? `, signal ${params.exit.signal}` : "";
 		parts.push(`exited with code ${codePart}${signalPart} before binding its socket`);
 	}
+	if (params.exit.inputError) parts.push(`startup input failed: ${params.exit.inputError.message}`);
 	const tail = params.logTail.trim();
 	if (tail.length > 0) parts.push(`stderr:\n${tail}`);
 	return parts.join(": ");
 }
 function spawnQueueOwnerProcess(options) {
-	const payloadPath = writeQueueOwnerPayloadFile(JSON.stringify(options));
+	const payload = JSON.stringify(options);
 	let exited = false;
 	let code = null;
 	let signal = null;
 	let spawnError;
+	let inputError;
 	let capturing = true;
 	let stderrTail = Buffer.alloc(0);
-	const child = spawn(process.execPath, resolveQueueOwnerSpawnArgs(), buildQueueOwnerSpawnOptions(payloadPath, { captureStderr: true }));
+	const child = spawn(process.execPath, resolveQueueOwnerSpawnArgs(), {
+		detached: true,
+		stdio: [
+			"pipe",
+			"ignore",
+			"pipe"
+		],
+		windowsHide: true
+	});
+	child.stdin.on("error", (error) => {
+		inputError = error;
+	});
+	child.stdin.end(payload);
 	const stopStartupCapture = () => {
 		if (!capturing) return;
 		capturing = false;
@@ -2424,7 +2363,8 @@ function spawnQueueOwnerProcess(options) {
 			exited,
 			code,
 			signal,
-			...spawnError ? { spawnError } : {}
+			...spawnError ? { spawnError } : {},
+			...inputError ? { inputError } : {}
 		}),
 		readLogTail: (maxBytes = QUEUE_OWNER_STARTUP_STDERR_MAX_BYTES) => {
 			const start = Math.max(0, stderrTail.length - maxBytes);
@@ -2435,10 +2375,11 @@ function spawnQueueOwnerProcess(options) {
 }
 //#endregion
 //#region src/session/events.ts
-const LOCK_RETRY_MS = 15;
-const EVENT_LOCK_STALE_MS = 15e3;
 async function ensureSessionDir() {
-	await fs$1.mkdir(sessionBaseDir(), { recursive: true });
+	await fs$1.mkdir(sessionBaseDir(), {
+		recursive: true,
+		mode: 448
+	});
 }
 async function pathExists(filePath) {
 	try {
@@ -2479,71 +2420,16 @@ async function rotateSegments(sessionId, maxSegments) {
 	}
 	if (await pathExists(active)) await fs$1.rename(active, sessionEventSegmentPath(sessionId, 1));
 }
-function parseEventLockPayload(raw) {
-	try {
-		const parsed = JSON.parse(raw);
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
-		const record = parsed;
-		return {
-			pid: typeof record.pid === "number" ? record.pid : void 0,
-			created_at: typeof record.created_at === "string" ? record.created_at : void 0
-		};
-	} catch {
-		return {};
-	}
-}
-async function removeStaleEventLock(lockPath) {
-	try {
-		const parsed = parseEventLockPayload(await fs$1.readFile(lockPath, "utf8"));
-		const createdAtMs = parsed.created_at ? Date.parse(parsed.created_at) : NaN;
-		const lockAgeMs = Number.isFinite(createdAtMs) ? Date.now() - createdAtMs : Number.POSITIVE_INFINITY;
-		if (isProcessAlive(parsed.pid) && lockAgeMs <= EVENT_LOCK_STALE_MS) return false;
-		await fs$1.unlink(lockPath);
-		incrementPerfCounter("session.events.stale_lock_recovered");
-		return true;
-	} catch (error) {
-		if (error.code === "ENOENT") return true;
-		return false;
-	}
-}
-async function acquireEventsLock(sessionId) {
-	await ensureSessionDir();
-	const lockPath = sessionEventLockPath(sessionId);
-	const payload = JSON.stringify({
-		pid: process.pid,
-		created_at: (/* @__PURE__ */ new Date()).toISOString()
-	}, null, 2);
-	for (;;) try {
-		await fs$1.writeFile(lockPath, `${payload}\n`, {
-			encoding: "utf8",
-			flag: "wx"
-		});
-		return { filePath: lockPath };
-	} catch (error) {
-		if (error.code !== "EEXIST") throw error;
-		if (await removeStaleEventLock(lockPath)) continue;
-		await new Promise((resolve) => {
-			setTimeout(resolve, LOCK_RETRY_MS);
-		});
-	}
-}
-async function releaseEventsLock(lock) {
-	await fs$1.unlink(lock.filePath).catch((error) => {
-		if (error.code !== "ENOENT") throw error;
-	});
-}
 var SessionEventWriter = class SessionEventWriter {
 	record;
-	lock;
 	maxSegmentBytes;
 	maxSegments;
 	activePath;
 	activeSizeBytes;
 	segmentCount;
 	closed = false;
-	constructor(record, lock, options, state) {
+	constructor(record, options, state) {
 		this.record = record;
-		this.lock = lock;
 		this.maxSegmentBytes = options.maxSegmentBytes;
 		this.maxSegments = options.maxSegments;
 		this.activePath = state.activePath;
@@ -2551,13 +2437,12 @@ var SessionEventWriter = class SessionEventWriter {
 		this.segmentCount = state.segmentCount;
 	}
 	static async open(record, options = {}) {
-		const lock = await acquireEventsLock(record.acpxRecordId);
 		const maxSegmentBytes = options.maxSegmentBytes ?? record.eventLog.max_segment_bytes ?? 67108864;
 		const maxSegments = options.maxSegments ?? record.eventLog.max_segments ?? 5;
 		const activePath = sessionEventActivePath(record.acpxRecordId);
 		const activeSizeBytes = await statSize(activePath);
 		const segmentCount = await resolveInitialSegmentCount(record, maxSegments);
-		return new SessionEventWriter(record, lock, {
+		return new SessionEventWriter(record, {
 			maxSegmentBytes,
 			maxSegments
 		}, {
@@ -2588,7 +2473,11 @@ var SessionEventWriter = class SessionEventWriter {
 					this.segmentCount = Math.min(this.segmentCount + 1, this.maxSegments);
 					incrementPerfCounter("session.events.rotate");
 				}
-				await fs$1.appendFile(this.activePath, line, "utf8");
+				await appendRegularFile({
+					filePath: this.activePath,
+					content: line,
+					mode: 384
+				});
 				this.activeSizeBytes += lineBytes;
 				this.record.lastSeq += 1;
 				if (Object.hasOwn(message, "id")) {
@@ -2619,11 +2508,132 @@ var SessionEventWriter = class SessionEventWriter {
 			if (options.checkpoint !== false) await writeSessionRecord(this.record);
 		} finally {
 			this.closed = true;
-			await releaseEventsLock(this.lock);
 		}
 	}
 };
 //#endregion
+//#region src/session/turn-ownership.ts
+const LOCK_RETRY_MS = 15;
+const INCOMPLETE_RESERVATION_GRACE_MS = 15e3;
+let lastCreatedAt = 0;
+async function readLock(filePath) {
+	try {
+		const stat = await fs$1.lstat(filePath, { bigint: true });
+		if (!stat.isFile()) throw new Error(`Session turn lock is not a regular file: ${filePath}`);
+		return {
+			stat,
+			payload: await fs$1.readFile(filePath, "utf8")
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+}
+function lockPid(payload) {
+	try {
+		const pid = JSON.parse(payload)?.pid;
+		return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : void 0;
+	} catch {
+		return;
+	}
+}
+async function removeObservedLock(filePath, observed) {
+	const current = await readLock(filePath);
+	if (!current) return true;
+	if (current.payload !== observed.payload || current.stat.mtimeNs !== observed.stat.mtimeNs || current.stat.size !== observed.stat.size) return false;
+	await fs$1.unlink(filePath).catch((error) => {
+		if (error.code !== "ENOENT") throw error;
+	});
+	return true;
+}
+async function recoverAbandonedLock(filePath) {
+	const observed = await readLock(filePath);
+	if (!observed) return;
+	const pid = lockPid(observed.payload);
+	if (pid === process.pid || isProcessAlive(pid)) return;
+	if (!pid && Date.now() - Number(observed.stat.mtimeMs) <= INCOMPLETE_RESERVATION_GRACE_MS) return;
+	if (await removeObservedLock(filePath, observed)) incrementPerfCounter("session.events.stale_lock_recovered");
+}
+async function publishLock(filePath, payload, signal) {
+	try {
+		await withTempFile({
+			rootDir: path.dirname(filePath),
+			prefix: "session-turn",
+			fileName: "lock"
+		}, async (temporaryPath) => {
+			await fs$1.writeFile(temporaryPath, payload, {
+				encoding: "utf8",
+				flag: "wx",
+				mode: 384
+			});
+			signal?.throwIfAborted();
+			try {
+				await fs$1.link(temporaryPath, filePath);
+			} catch (error) {
+				if (!isHardlinkFallbackError(error)) throw error;
+				await fs$1.writeFile(filePath, payload, {
+					encoding: "utf8",
+					flag: "wx",
+					mode: 384
+				});
+			}
+		});
+	} catch (error) {
+		await removePublishedLock(filePath, payload).catch(() => {});
+		throw error;
+	}
+}
+async function removePublishedLock(filePath, payload) {
+	const current = await readLock(filePath);
+	if (current?.payload === payload) await removeObservedLock(filePath, current);
+}
+async function observePublishedLock(filePath, payload, signal) {
+	try {
+		const observed = await readLock(filePath);
+		if (observed?.payload !== payload) throw new Error(`Session turn ownership changed before admission: ${filePath}`);
+		signal?.throwIfAborted();
+		return { [Symbol.asyncDispose]: async () => {
+			await removeObservedLock(filePath, observed);
+		} };
+	} catch (error) {
+		await removePublishedLock(filePath, payload).catch(() => {});
+		throw error;
+	}
+}
+async function acquireSessionTurn(recordId, signal) {
+	const filePath = sessionEventLockPath(recordId);
+	await fs$1.mkdir(path.dirname(filePath), {
+		recursive: true,
+		mode: 448
+	});
+	lastCreatedAt = Math.max(Date.now(), lastCreatedAt + 1);
+	const payload = `${JSON.stringify({
+		pid: process.pid,
+		created_at: new Date(lastCreatedAt).toISOString()
+	}, null, 2)}\n`;
+	for (;;) {
+		signal?.throwIfAborted();
+		try {
+			await publishLock(filePath, payload, signal);
+			break;
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			await recoverAbandonedLock(filePath);
+			await setTimeout$1(LOCK_RETRY_MS, void 0, { signal });
+		}
+	}
+	return await observePublishedLock(filePath, payload, signal);
+}
+//#endregion
+//#region src/cli/output/discard.ts
+const DISCARD_OUTPUT_FORMATTER = {
+	setContext() {},
+	onAcpMessage() {},
+	onError() {},
+	onPermissionEscalation() {},
+	flush() {}
+};
+//#endregion
 //#region src/cli/session/runtime.ts
 const INTERRUPT_CANCEL_WAIT_MS = 2500;
 var QueueTaskOutputFormatter = class {
@@ -2662,13 +2672,6 @@ var QueueTaskOutputFormatter = class {
 	}
 	flush() {}
 };
-const DISCARD_OUTPUT_FORMATTER = {
-	setContext() {},
-	onAcpMessage() {},
-	onError() {},
-	onPermissionEscalation() {},
-	flush() {}
-};
 function markOutputAlreadyEmitted(error, outputAlreadyEmitted) {
 	if (!outputAlreadyEmitted || !error || typeof error !== "object") return;
 	error.outputAlreadyEmitted = true;
@@ -2725,29 +2728,6 @@ function toPromptResult(stopReason, sessionId, client, meta) {
 function requestedModelId(value) {
 	return typeof value === "string" ? value.trim() : "";
 }
-function mergeConnectedModelState(state, connectedState) {
-	if (!connectedState) return state;
-	const nextState = cloneSessionAcpxState(state) ?? {};
-	mergeConnectedAdvertisedModelState(nextState, connectedState);
-	mergeConnectedModelPreferences(nextState, connectedState);
-	return nextState;
-}
-function mergeConnectedAdvertisedModelState(nextState, connectedState) {
-	if (connectedState.config_options !== void 0) nextState.config_options = structuredClone(connectedState.config_options);
-	else delete nextState.config_options;
-	if (connectedState.current_model_id !== void 0) nextState.current_model_id = connectedState.current_model_id;
-	else delete nextState.current_model_id;
-	if (connectedState.available_models) nextState.available_models = [...connectedState.available_models];
-	else delete nextState.available_models;
-	if (connectedState.model_control) nextState.model_control = connectedState.model_control;
-	else delete nextState.model_control;
-}
-function mergeConnectedModelPreferences(nextState, connectedState) {
-	if (connectedState.session_options) nextState.session_options = cloneSessionAcpxState(connectedState)?.session_options;
-	if (connectedState.desired_mode_id !== void 0) nextState.desired_mode_id = connectedState.desired_mode_id;
-	if (connectedState.desired_config_options) nextState.desired_config_options = { ...connectedState.desired_config_options };
-	else delete nextState.desired_config_options;
-}
 async function applyPromptModelIfAdvertised(params) {
 	const requestedModel = requestedModelId(params.requestedModel);
 	if (!requestedModel) return;
@@ -2838,23 +2818,20 @@ function emitPromptDisconnectNotice(snapshot, verbose) {
 	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);
+async function preparePromptRetry(error, attempt, maxRetries, hasSideEffects, suppressSdkConsoleErrors) {
+	if (attempt < maxRetries && !hasSideEffects() && isRetryablePromptError(error)) {
+		const delayMs = Math.min(1e3 * 2 ** attempt, 1e4);
+		emitPromptRetryNotice({
+			error,
+			delayMs,
+			attempt: attempt + 1,
+			maxRetries,
+			suppressSdkConsoleErrors
+		});
+		await waitMs(delayMs);
+		return !hasSideEffects();
+	}
+	return false;
 }
 function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatter) {
 	return {
@@ -2878,6 +2855,7 @@ function buildQueuedTaskRunOptions(sessionRecordId, task, options, outputFormatt
 		onClientClosed: options.onClientClosed,
 		onPromptActive: options.onPromptActive,
 		handleProcessInterrupts: options.handleProcessInterrupts,
+		waitSignal: options.waitSignal,
 		client: options.sharedClient
 	};
 }
@@ -2919,7 +2897,64 @@ async function runQueuedTask(sessionRecordId, task, options) {
 		task.close();
 	}
 }
+async function waitForSessionTurn(options) {
+	const waiting = new AbortController();
+	const onInterrupt = () => waiting.abort(new InterruptedError());
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	for (const signal of signals) process.once(signal, onInterrupt);
+	const timeoutMs = options.timeoutMs;
+	const timeout = timeoutMs != null && timeoutMs > 0 ? setTimeout(() => waiting.abort(new TimeoutError(timeoutMs)), timeoutMs) : void 0;
+	const signal = options.waitSignal ? AbortSignal.any([waiting.signal, options.waitSignal]) : waiting.signal;
+	try {
+		const { acpxRecordId } = await resolveSessionRecord(options.sessionRecordId);
+		return {
+			recordId: acpxRecordId,
+			ownership: await acquireSessionTurn(acpxRecordId, signal)
+		};
+	} catch (error) {
+		signal.throwIfAborted();
+		throw error;
+	} finally {
+		clearTimeout(timeout);
+		for (const signal of signals) process.off(signal, onInterrupt);
+	}
+}
 async function runSessionPrompt(options) {
+	let turn;
+	try {
+		turn = await waitForSessionTurn(options);
+	} catch (error) {
+		if (options.waitSignal?.aborted && error === options.waitSignal.reason) {
+			const record = await resolveSessionRecord(options.sessionRecordId);
+			return {
+				sessionId: record.acpxRecordId,
+				stopReason: "cancelled",
+				permissionStats: {
+					requested: 0,
+					approved: 0,
+					denied: 0,
+					cancelled: 0
+				},
+				record,
+				resumed: false
+			};
+		}
+		throw error;
+	}
+	try {
+		return await runOwnedSessionPrompt({
+			...options,
+			sessionRecordId: turn.recordId
+		});
+	} finally {
+		await turn.ownership[Symbol.asyncDispose]();
+	}
+}
+async function runOwnedSessionPrompt(options) {
 	const stopTotalTimer = startPerfTimer("runtime.prompt.total");
 	const output = options.outputFormatter;
 	const shouldMarkAcpErrorsEmitted = rendersAcpErrors(options.errorEmissionPolicy);
@@ -2927,13 +2962,12 @@ async function runSessionPrompt(options) {
 		return await resolveSessionRecord(options.sessionRecordId);
 	});
 	const conversation = cloneSessionConversation(record);
-	let acpxState = cloneSessionAcpxState(record.acpx);
+	record.acpx = cloneSessionAcpxState(record.acpx);
 	const promptStartedAt = isoNow();
 	const promptMessageId = recordPromptSubmission(conversation, options.prompt, promptStartedAt);
 	record.lastPromptAt = promptStartedAt;
 	record.lastUsedAt = promptStartedAt;
 	applyConversation(record, conversation);
-	record.acpx = acpxState;
 	await writeSessionRecord(record);
 	output.setContext({ sessionId: record.acpxRecordId });
 	const eventWriter = await measurePerf("session.events.open", async () => {
@@ -2975,7 +3009,6 @@ async function runSessionPrompt(options) {
 			await flushPendingMessages(false);
 			record.lastUsedAt = isoNow();
 			applyConversation(record, conversation);
-			record.acpx = acpxState;
 			await preserveClosedState();
 			await eventWriter.checkpoint();
 		},
@@ -3026,14 +3059,14 @@ async function runSessionPrompt(options) {
 		},
 		onSessionUpdate: (notification) => {
 			if (promptTurnActive) promptTurnHadSideEffects = true;
-			acpxState = recordSessionUpdate(conversation, acpxState, notification);
+			record.acpx = recordSessionUpdate(conversation, record.acpx, notification);
 			trimConversationForRuntime(conversation);
 			liveCheckpoint.request();
 			options.onSessionUpdate?.(notification);
 		},
 		onClientOperation: (operation) => {
 			if (promptTurnActive) promptTurnHadSideEffects = true;
-			acpxState = recordClientOperation(conversation, acpxState, operation);
+			record.acpx = recordClientOperation(conversation, record.acpx, operation);
 			trimConversationForRuntime(conversation);
 			liveCheckpoint.request();
 			options.onClientOperation?.(operation);
@@ -3052,15 +3085,15 @@ async function runSessionPrompt(options) {
 			await client.setSessionMode(activeSessionIdForControl, modeId);
 		},
 		setSessionModel: async (modelId) => {
-			const models = advertisedModelState(acpxState);
+			const models = advertisedModelState(record.acpx);
 			const response = await client.setSessionModel(activeSessionIdForControl, modelId, models);
-			acpxState = applyModelSelection(acpxState, modelId, response);
+			record.acpx = applyModelSelection(record.acpx, modelId, response);
 			return response;
 		},
 		setSessionConfigOption: async (configId, value) => {
-			const modelConfigId = advertisedModelState(acpxState)?.configId;
+			const modelConfigId = advertisedModelState(record.acpx)?.configId;
 			const response = await client.setSessionConfigOption(activeSessionIdForControl, configId, value);
-			acpxState = applyConfigOptionSelection(acpxState, configId, value, response, modelConfigId);
+			record.acpx = applyConfigOptionSelection(record.acpx, configId, value, response, modelConfigId);
 			return response;
 		}
 	};
@@ -3095,7 +3128,6 @@ async function runSessionPrompt(options) {
 					}
 				});
 			});
-			acpxState = mergeConnectedModelState(acpxState, record.acpx);
 			flushConnectOutput(connected.loadError);
 			emitConnectPerfMetric(connectStartedAt, options.verbose);
 			return connected;
@@ -3134,11 +3166,8 @@ async function runSessionPrompt(options) {
 	};
 	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);
+		if (snapshot.lastExit?.unexpectedDuringPrompt !== true && await preparePromptRetry(error, attempt, options.promptRetries ?? 0, () => promptTurnHadSideEffects, options.suppressSdkConsoleErrors)) return;
+		await failRuntimePrompt(error, snapshot);
 	};
 	const failRuntimePrompt = async (error, snapshot) => {
 		promptTurnActive = false;
@@ -3153,7 +3182,6 @@ async function runSessionPrompt(options) {
 		output.flush();
 		record.lastUsedAt = isoNow();
 		applyConversation(record, conversation);
-		record.acpx = acpxState;
 		const propagated = error instanceof Error ? error : new Error(formatErrorMessage(error));
 		attachAcpErrorPayload(propagated, normalizedError.acp);
 		propagated.outputAlreadyEmitted = matchedAcpError !== void 0 && shouldMarkAcpErrorsEmitted;
@@ -3165,7 +3193,7 @@ async function runSessionPrompt(options) {
 		for (let attempt = 0;; attempt++) try {
 			return await runPromptAttempt(sessionId, attempt);
 		} catch (error) {
-			if (await handlePromptFailure(error, attempt) === "retry") continue;
+			await handlePromptFailure(error, attempt);
 		}
 	};
 	const savePromptSuccess = async (response) => {
@@ -3178,7 +3206,6 @@ async function runSessionPrompt(options) {
 		record.protocolVersion = client.initializeResult?.protocolVersion;
 		record.agentCapabilities = client.initializeResult?.agentCapabilities;
 		applyConversation(record, conversation);
-		record.acpx = acpxState;
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		stopTotalTimer();
 		return response;
@@ -3193,7 +3220,6 @@ async function runSessionPrompt(options) {
 			timeoutMs: options.timeoutMs,
 			suppressWarnings: options.suppressSdkConsoleErrors
 		});
-		acpxState = cloneSessionAcpxState(record.acpx);
 		output.setContext({ sessionId: record.acpxRecordId });
 		await liveCheckpoint.checkpoint();
 		const response = await savePromptSuccess(await runPromptWithRetries(activeSessionId));
@@ -3210,7 +3236,6 @@ async function runSessionPrompt(options) {
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		record.lastUsedAt = isoNow();
 		applyConversation(record, conversation);
-		record.acpx = acpxState;
 		await flushPendingMessages(false).catch(() => {});
 		if (closeClientOnExit) await client.close();
 	};
@@ -3233,7 +3258,6 @@ async function runSessionPrompt(options) {
 		if (closeClientOnExit) await client.close();
 		applyLifecycleSnapshotToRecord(record, client.getAgentLifecycleSnapshot());
 		applyConversation(record, conversation);
-		record.acpx = acpxState;
 		await liveCheckpoint.flush().catch(() => {});
 		await flushPendingMessages(false).catch(() => {});
 		await preserveClosedState().catch(() => {});
@@ -3290,10 +3314,7 @@ async function runOnce(options) {
 		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;
-			}
+			if (await preparePromptRetry(error, attempt, maxRetries, () => promptTurnHadSideEffects, options.suppressSdkConsoleErrors)) continue;
 			promptTurnActive = false;
 			throw error;
 		}
@@ -3456,19 +3477,17 @@ function logDeferredCancelFailure(error, verbose) {
 	process.stderr.write(`[acpx] failed to apply deferred cancel: ${formatErrorMessage(error)}\n`);
 }
 function queueOwnerExitIsFatal(exit) {
-	return exit.exited && (exit.spawnError !== void 0 || exit.code !== 0 || exit.signal !== null);
+	return exit.exited && (exit.spawnError !== void 0 || exit.inputError !== void 0 || exit.code !== 0 || exit.signal !== null);
 }
 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.sharedClient.close().catch(() => {});
 	await params.owner?.close();
 	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) {
@@ -3525,9 +3544,7 @@ function createQueueOwnerShutdownController(params) {
 			shutdownPromise ??= (async () => {
 				await activeTurnShutdown;
 				await closeQueueOwnerRuntime({
-					lease: params.lease,
 					owner: params.getOwner(),
-					heartbeatTimer: void 0,
 					turnController: params.turnController,
 					sharedClient: params.sharedClient,
 					sessionId: params.sessionId,
@@ -3553,6 +3570,13 @@ async function runSessionQueueOwner(options) {
 		fingerprint: options.mcpConfigFingerprint
 	});
 	if (!lease) return;
+	try {
+		await runQueueOwnerRuntime(options, lease);
+	} finally {
+		await releaseQueueOwnerLease(lease);
+	}
+}
+async function runQueueOwnerRuntime(options, lease) {
 	const sessionRecord = await resolveSessionRecord(options.sessionId);
 	let owner;
 	let heartbeatTimer;
@@ -3584,15 +3608,14 @@ async function runSessionQueueOwner(options) {
 		return true;
 	};
 	const runPromptTurn = async (run) => {
-		turnController.beginTurn();
+		const waitSignal = turnController.beginTurn();
 		try {
-			return await run();
+			return await run(waitSignal);
 		} finally {
 			turnController.endTurn();
 		}
 	};
 	const shutdown = createQueueOwnerShutdownController({
-		lease,
 		getOwner: () => owner,
 		stopHeartbeat: () => {
 			if (heartbeatTimer) {
@@ -3652,7 +3675,7 @@ async function runSessionQueueOwner(options) {
 			const task = await owner.nextTask(pollTimeoutMs);
 			if (!task) break;
 			isFirstTask = false;
-			const turnPromise = runPromptTurn(async () => {
+			const turnPromise = runPromptTurn(async (waitSignal) => {
 				try {
 					await runQueuedTask(options.sessionId, task, {
 						sharedClient,
@@ -3670,7 +3693,8 @@ async function runSessionQueueOwner(options) {
 							turnController.markPromptActive();
 							await applyPendingCancel();
 						},
-						handleProcessInterrupts: false
+						handleProcessInterrupts: false,
+						waitSignal
 					});
 				} finally {
 					checkpointPerfMetricsCapture();
@@ -3749,7 +3773,6 @@ var session_exports = /* @__PURE__ */ __exportAll({
 	listAgentSessions: () => listAgentSessions,
 	listSessions: () => listSessions,
 	listSessionsForAgent: () => listSessionsForAgent,
-	mergeConnectedModelState: () => mergeConnectedModelState,
 	normalizeQueueOwnerTtlMs: () => normalizeQueueOwnerTtlMs,
 	pruneSessions: () => pruneSessions,
 	queueOwnerRuntimeTestInternals: () => queueOwnerRuntimeTestInternals,
@@ -4019,13 +4042,7 @@ function isFinalStatus(status) {
 	return status === "completed" || status === "failed";
 }
 function toStatusLabel(status) {
-	switch (status) {
-		case "in_progress": return "running";
-		case "pending": return "pending";
-		case "completed": return "completed";
-		case "failed": return "failed";
-		default: return "running";
-	}
+	return isFinalStatus(status) || status === "pending" ? status : "running";
 }
 function asRecord(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
@@ -4058,14 +4075,7 @@ function indentBlock(value, prefix) {
 	return value.split("\n").map((line) => `${prefix}${line}`).join("\n");
 }
 function dedupeStrings(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const value of values) {
-		if (seen.has(value)) continue;
-		seen.add(value);
-		result.push(value);
-	}
-	return result;
+	return [...new Set(values)];
 }
 function safeJson(value, spacing) {
 	const seen = /* @__PURE__ */ new WeakSet();
@@ -4374,7 +4384,6 @@ var TextOutputFormatter = class {
 	thoughtBuffer = "";
 	wroteAny = false;
 	atLineStart = true;
-	section = null;
 	constructor(stdout, suppressReads) {
 		this.stdout = stdout;
 		this.useColor = Boolean(stdout.isTTY);
@@ -4382,6 +4391,12 @@ var TextOutputFormatter = class {
 	}
 	setContext(_context) {}
 	onAcpMessage(message) {
+		const notice = parsePermissionNotice(message);
+		if (notice) {
+			this.beginSection();
+			this.writeLine(`${this.bold("[permission]")} ${notice}`);
+			return;
+		}
 		const notification = extractSessionUpdateNotification(message);
 		if (notification) {
 			this.renderSessionUpdate(notification);
@@ -4417,7 +4432,7 @@ var TextOutputFormatter = class {
 	renderSessionUpdateBody(update) {
 		switch (update.sessionUpdate) {
 			case "agent_message_chunk":
-				if (update.content.type === "text") this.writeAssistantChunk(update.content.text);
+				if (update.content.type === "text") this.write(update.content.text);
 				return;
 			case "agent_thought_chunk":
 				if (update.content.type === "text") this.thoughtBuffer += update.content.text;
@@ -4435,24 +4450,24 @@ var TextOutputFormatter = class {
 		}
 	}
 	renderPlanUpdate(entries) {
-		this.beginSection("plan");
+		this.beginSection();
 		this.writeLine(this.bold("[plan]"));
 		for (const entry of entries) this.writeLine(`  - [${entry.status}] ${entry.content}`);
 	}
 	renderDone(stopReason) {
 		this.flushThoughtBuffer();
-		this.beginSection("done");
+		this.beginSection();
 		this.writeLine(this.dim(`[done] ${stopReason}`));
 	}
 	onError(params) {
 		this.flushThoughtBuffer();
-		this.beginSection("done");
+		this.beginSection();
 		this.writeLine(this.formatAnsi(`[error] ${params.code}: ${params.message}`, "31"));
 		for (const hint of getTextErrorRemediationHints(params)) this.writeLine(this.dim(hint));
 	}
 	onClientOperation(operation) {
 		this.flushThoughtBuffer();
-		this.beginSection("client");
+		this.beginSection();
 		const normalizedStatus = operation.status === "completed" ? "completed" : operation.status === "failed" ? "failed" : "in_progress";
 		const statusText = this.colorStatus(operation.status, normalizedStatus);
 		this.writeLine(`${this.bold("[client]")} ${operation.summary} (${statusText})`);
@@ -4463,7 +4478,7 @@ var TextOutputFormatter = class {
 	}
 	onPermissionEscalation(event) {
 		this.flushThoughtBuffer();
-		this.beginSection("client");
+		this.beginSection();
 		this.writeLine(`${this.bold("[permission]")} ${event.message}`);
 		const details = [
 			`sessionId: ${event.sessionId}`,
@@ -4489,21 +4504,15 @@ var TextOutputFormatter = class {
 	writeLine(line) {
 		this.write(`${line}\n`);
 	}
-	beginSection(next) {
+	beginSection() {
 		if (!this.atLineStart) this.write("\n");
 		if (this.wroteAny) this.write("\n");
-		this.section = next;
-	}
-	writeAssistantChunk(text) {
-		if (!text) return;
-		this.section = "assistant";
-		this.write(text);
 	}
 	flushThoughtBuffer() {
 		const thought = truncate(normalizeLineEndings(this.thoughtBuffer).trim(), MAX_THOUGHT_CHARS);
 		this.thoughtBuffer = "";
 		if (!thought) return;
-		this.beginSection("thought");
+		this.beginSection();
 		const [firstLine, ...restLines] = thought.split("\n");
 		this.writeLine(this.dim(`[thinking] ${firstLine}`));
 		for (const line of restLines) this.writeLine(this.dim(`           ${line}`));
@@ -4512,17 +4521,25 @@ var TextOutputFormatter = class {
 		const state = this.getOrCreateToolState(update.toolCallId);
 		this.mergeToolState(state, update);
 		const status = asStatus(state.status);
-		if (isFinalStatus(status)) {
-			const signature = this.toolSignature(state);
-			if (signature !== state.finalSignature) {
-				state.finalSignature = signature;
-				this.renderFinalToolState(state, status);
-			}
-			return;
-		}
-		if (state.startedPrinted) return;
-		state.startedPrinted = true;
-		this.renderStartingToolState(state, status);
+		const final = isFinalStatus(status);
+		if (!final && state.startedPrinted) return;
+		const display = {
+			input: summarizeToolInput(state.rawInput),
+			files: formatLocations(state.locations),
+			output: final ? renderToolOutput(state, this.suppressReads) : void 0
+		};
+		if (final) {
+			const payload = {
+				title: state.title,
+				status: state.status,
+				kind: state.kind,
+				...display
+			};
+			const signature = safeJson(payload, 0) ?? JSON.stringify(payload);
+			if (signature === state.finalSignature) return;
+			state.finalSignature = signature;
+		} else state.startedPrinted = true;
+		this.renderToolState(state, status, display);
 	}
 	getOrCreateToolState(toolCallId) {
 		const existing = this.toolStates.get(toolCallId);
@@ -4549,42 +4566,17 @@ var TextOutputFormatter = class {
 		if (update.rawOutput !== void 0) state.rawOutput = update.rawOutput;
 		if (update.content !== void 0) state.content = update.content;
 	}
-	toolSignature(state) {
-		const signaturePayload = {
-			title: state.title,
-			status: state.status,
-			kind: state.kind,
-			input: summarizeToolInput(state.rawInput),
-			files: formatLocations(state.locations),
-			output: renderToolOutput(state, this.suppressReads)
-		};
-		return safeJson(signaturePayload, 0) ?? JSON.stringify(signaturePayload);
-	}
-	renderStartingToolState(state, status) {
-		this.beginSection("tool");
-		const title = state.title ?? state.id;
-		const label = status === "pending" ? "pending" : "running";
-		const statusText = this.colorStatus(label, status);
-		this.writeLine(`${this.bold("[tool]")} ${title} (${statusText})`);
-		const input = summarizeToolInput(state.rawInput);
-		if (input) this.writeLine(`  input: ${input}`);
-		const files = formatLocations(state.locations);
-		if (files) this.writeLine(`  files: ${files}`);
-	}
-	renderFinalToolState(state, status) {
-		this.beginSection("tool");
+	renderToolState(state, status, display) {
+		this.beginSection();
 		const title = state.title ?? state.id;
 		const statusText = this.colorStatus(toStatusLabel(status), status);
 		this.writeLine(`${this.bold("[tool]")} ${title} (${statusText})`);
-		if (state.kind) this.writeLine(`  kind: ${state.kind}`);
-		const input = summarizeToolInput(state.rawInput);
-		if (input) this.writeLine(`  input: ${input}`);
-		const files = formatLocations(state.locations);
-		if (files) this.writeLine(`  files: ${files}`);
-		const output = renderToolOutput(state, this.suppressReads);
-		if (output) {
+		if (isFinalStatus(status) && state.kind) this.writeLine(`  kind: ${state.kind}`);
+		if (display.input) this.writeLine(`  input: ${display.input}`);
+		if (display.files) this.writeLine(`  files: ${display.files}`);
+		if (display.output) {
 			this.writeLine("  output:");
-			this.writeLine(indentBlock(limitOutputBlock(output), "    "));
+			this.writeLine(indentBlock(limitOutputBlock(display.output), "    "));
 		}
 	}
 	formatAnsi(text, code) {
@@ -4618,6 +4610,11 @@ var QuietOutputFormatter = class {
 	}
 	setContext(_context) {}
 	onAcpMessage(message) {
+		const notice = parsePermissionNotice(message);
+		if (notice) {
+			this.stderr.write(`[acpx] permission: ${notice.replace(/\r\n?|\n/g, " ")}\n`);
+			return;
+		}
 		const update = extractSessionUpdateNotification(message);
 		if (update?.update.sessionUpdate === "agent_message_chunk" && update.update.content.type === "text") {
 			this.chunks.push(update.update.content.text);
@@ -4709,6 +4706,6 @@ function createOutputFormatter(format, options = {}) {
 	}
 }
 //#endregion
-export { runSessionQueueOwner as a, buildQueueOwnerArgOverride as c, createSessionWithClient as d, cancelSessionPrompt as f, __exportAll as g, isProcessAlive 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 };
+export { runSessionQueueOwner as a, DISCARD_OUTPUT_FORMATTER as c, installPerfMetricsCapture as d, createSessionWithClient as f, __exportAll as g, DEFAULT_QUEUE_OWNER_TTL_MS as h, session_exports as i, buildQueueOwnerArgOverride as l, probeQueueOwnerHealth as m, getTextErrorRemediationHints as n, runOnce as o, cancelSessionPrompt as p, output_exports as r, sendSessionDirect as s, createOutputFormatter as t, flushPerfMetricsCapture as u };
 
-//# sourceMappingURL=output-CIVecnHU.js.map
+//# sourceMappingURL=output-uo5a27KB.js.map