acpx 0.17.0 → 0.18.0

package/dist/{ipc-D3akHMEq.js → ipc-BJrvfNXr.js}

@@ -1,4 +1,4 @@
-import { n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DU6mhZBL.js";
+import { n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DdKB-zia.js";
 import { statSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -9,6 +9,7 @@ import { root } from "@openclaw/fs-safe";
 import { z } from "zod";
 import { createHash, randomInt, randomUUID } from "node:crypto";
 import { isHardlinkFallbackError } from "@openclaw/fs-safe/durability";
+import { acquireFileLock } from "@openclaw/fs-safe/file-lock";
 import net from "node:net";
 //#region src/errors.ts
 var AcpxOperationalError = class extends Error {
@@ -179,8 +180,8 @@ var QueueConnectionError = class extends AcpxOperationalError {};
 var QueueProtocolError = class extends AcpxOperationalError {};
 var PermissionDeniedError = class extends AcpxOperationalError {};
 var PermissionPromptUnavailableError = class extends AcpxOperationalError {
-	constructor() {
-		super("Permission prompt unavailable in non-interactive mode");
+	constructor(message = "Permission prompt unavailable in non-interactive mode") {
+		super(message);
 	}
 };
 //#endregion
@@ -310,6 +311,15 @@ function isProcessAlive(pid) {
 		return false;
 	}
 }
+function isProcessDefinitelyDead(pid) {
+	if (!pid || !Number.isSafeInteger(pid) || pid <= 0 || pid === process.pid) return false;
+	try {
+		process.kill(pid, 0);
+		return false;
+	} catch (error) {
+		return error.code === "ESRCH";
+	}
+}
 //#endregion
 //#region \0@oxc-project+runtime@0.149.0/helpers/esm/usingCtx.js
 function _usingCtx() {
@@ -1871,11 +1881,12 @@ function closedAtOrLastUsedAt(record) {
 	return record.closedAt ?? record.lastUsedAt;
 }
 function isSessionStreamFile(fileName, safeId) {
-	return fileName === `${safeId}.stream.ndjson` || fileName === `${safeId}.stream.lock` || fileName.startsWith(`${safeId}.stream.`);
+	const segmentPrefix = `${safeId}.stream.`;
+	return fileName === `${safeId}.stream.ndjson` || fileName === `${safeId}.stream.lock` || fileName.startsWith(segmentPrefix) && /^\d+\.ndjson$/.test(fileName.slice(segmentPrefix.length));
 }
 async function pruneSessions(options = {}) {
 	await ensureSessionDir();
-	const records = await loadPrunableRecords(filterPruneCandidates(await loadSessionIndexEntries(), options.agentCommand), options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0));
+	const records = await loadPrunableRecords((await loadSessionIndexEntries()).filter((entry) => isPruneCandidate(entry, options.agentCommand)), options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0), options.agentCommand);
 	if (options.dryRun) return {
 		pruned: records,
 		bytesFreed: 0,
@@ -1895,15 +1906,15 @@ async function pruneSessions(options = {}) {
 		dryRun: false
 	};
 }
-function filterPruneCandidates(entries, agentCommand) {
-	return entries.filter((entry) => entry.closed && (!agentCommand || entry.agentCommand === agentCommand));
+function isPruneCandidate(record, agentCommand) {
+	return record.closed === true && (!agentCommand || record.agentCommand === agentCommand);
 }
-async function loadPrunableRecords(entries, cutoff) {
+async function loadPrunableRecords(entries, cutoff, agentCommand) {
 	const records = [];
 	const cutoffIso = cutoff?.toISOString();
 	for (const entry of entries) {
 		const record = await loadRecordFromIndexEntry(entry);
-		if (record && isBeforeCutoff(record, cutoffIso)) records.push(record);
+		if (record && isPruneCandidate(record, agentCommand) && isBeforeCutoff(record, cutoffIso)) records.push(record);
 	}
 	return records;
 }
@@ -2124,6 +2135,156 @@ function queueSocketPath(sessionId, homeDir = os.homedir()) {
 	return path.join(queueSocketBaseDir(homeDir) ?? "/tmp", `${key}.sock`);
 }
 //#endregion
+//#region src/session/queue/lease-mutation.ts
+const GUARD_WAIT_MS = 2e3;
+const localMutations = /* @__PURE__ */ new Map();
+var QueueLeaseGuardSettlementError = class extends QueueConnectionError {
+	constructor(errors) {
+		super("Queue lease guard settlement failed; cleanup remains retryable", {
+			detailCode: "QUEUE_LEASE_GUARD_SETTLEMENT_FAILED",
+			origin: "queue",
+			retryable: false,
+			cause: new AggregateError(errors, "Queue lease mutation and settlement errors")
+		});
+	}
+};
+async function canonicalLeasePath(sessionId) {
+	const requested = queueLockFilePath(sessionId);
+	try {
+		return path.join(await fs$1.realpath(path.dirname(requested)), path.basename(requested));
+	} catch (error) {
+		if (error.code === "ENOENT") return path.resolve(requested);
+		throw error;
+	}
+}
+function guardOwnerHasExited({ payload }) {
+	return payload !== null && typeof payload === "object" && "pid" in payload && typeof payload.pid === "number" && isProcessDefinitelyDead(payload.pid);
+}
+async function acquireGuard(lockPath) {
+	return await acquireFileLock(lockPath, {
+		managerKey: "acpx.queue-lease-mutation",
+		lockPath: `${lockPath}.guard`,
+		staleMs: Infinity,
+		timeoutMs: GUARD_WAIT_MS,
+		retry: {
+			minTimeout: 5,
+			maxTimeout: 15,
+			factor: 1,
+			randomize: false
+		},
+		staleRecovery: "remove-if-unchanged",
+		payload: () => ({ pid: process.pid }),
+		shouldReclaim: guardOwnerHasExited,
+		shouldRemoveStaleLock: guardOwnerHasExited
+	});
+}
+function matchesReservation(value, expected) {
+	if (!value || typeof value !== "object") return false;
+	const record = value;
+	return record.pid === expected.pid && record.sessionId === expected.sessionId && record.ownerGeneration === expected.ownerGeneration;
+}
+async function rollbackReservation(lockPath, expected) {
+	try {
+		if (!(await fs$1.lstat(lockPath)).isFile()) return;
+		const raw = await fs$1.readFile(lockPath, "utf8");
+		let value;
+		try {
+			value = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (matchesReservation(value, expected)) await fs$1.unlink(lockPath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function settleReceipt(lockPath, receipt) {
+	if (receipt.reservation) {
+		if (!await receipt.guard.verifyStillHeld()) {
+			await receipt.guard.release();
+			receipt.guard = await acquireGuard(lockPath);
+		}
+		await rollbackReservation(lockPath, receipt.reservation);
+		receipt.reservation = void 0;
+	}
+	await receipt.guard.release();
+}
+async function settleFailedGuard(lockPath, state) {
+	const failed = state.failed;
+	if (!failed) return;
+	try {
+		await settleReceipt(lockPath, failed);
+		if (state.failed === failed) state.failed = void 0;
+	} catch (error) {
+		throw new QueueLeaseGuardSettlementError([error]);
+	}
+}
+async function locallySerialized(lockPath, run) {
+	let state = localMutations.get(lockPath);
+	if (!state) {
+		state = { tail: Promise.resolve() };
+		localMutations.set(lockPath, state);
+	}
+	const current = state;
+	const operation = current.tail.then(async () => await run(current));
+	const tail = operation.then(() => {}, () => {});
+	current.tail = tail;
+	try {
+		return await operation;
+	} finally {
+		if (current.tail === tail && !current.failed && localMutations.get(lockPath) === current) localMutations.delete(lockPath);
+	}
+}
+async function settlePendingQueueLeaseGuard(sessionId) {
+	if (localMutations.size === 0) return;
+	const lockPath = await canonicalLeasePath(sessionId);
+	if (!localMutations.has(lockPath)) return;
+	await locallySerialized(lockPath, async (state) => await settleFailedGuard(lockPath, state));
+}
+async function withQueueLeaseMutation(sessionId, mutate, reservation) {
+	await fs$1.mkdir(path.dirname(queueLockFilePath(sessionId)), {
+		recursive: true,
+		mode: 448
+	});
+	const lockPath = await canonicalLeasePath(sessionId);
+	const expected = reservation ? {
+		pid: reservation.pid,
+		sessionId: reservation.sessionId,
+		ownerGeneration: reservation.ownerGeneration
+	} : void 0;
+	const publishedReservation = () => reservation?.published ? expected : void 0;
+	return await locallySerialized(lockPath, async (state) => {
+		await settleFailedGuard(lockPath, state);
+		const guard = await acquireGuard(lockPath);
+		let outcome;
+		try {
+			outcome = {
+				ok: true,
+				value: await mutate()
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error
+			};
+		}
+		const published = publishedReservation();
+		const receipt = {
+			guard,
+			reservation: outcome.ok ? void 0 : published
+		};
+		try {
+			await settleReceipt(lockPath, receipt);
+		} catch (error) {
+			if (outcome.ok) receipt.reservation = published;
+			state.failed = receipt;
+			throw new QueueLeaseGuardSettlementError(outcome.ok ? [error] : [outcome.error, error]);
+		}
+		if (!outcome.ok) throw outcome.error;
+		return outcome.value;
+	});
+}
+//#endregion
 //#region src/session/queue/lease-store.ts
 const PROCESS_SIGTERM_GRACE_MS = process.platform === "win32" ? 4e3 : 12e3;
 const PROCESS_SIGKILL_GRACE_MS = 1500;
@@ -2141,12 +2302,18 @@ function parseQueueOwnerRecord(raw) {
 		heartbeatAt: record.heartbeatAt,
 		ownerGeneration: record.ownerGeneration,
 		queueDepth: record.queueDepth,
-		...record.sharedRuntime === true ? { sharedRuntime: true } : {},
-		...record.sessionWatch === true ? { sessionWatch: true } : {},
+		...parseQueueOwnerCapabilities(record),
 		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
 		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
 	};
 }
+function parseQueueOwnerCapabilities(record) {
+	return {
+		...record.sharedRuntime === true ? { sharedRuntime: true } : {},
+		...record.sessionWatch === true ? { sessionWatch: true } : {},
+		...record.persistsControlState === true ? { persistsControlState: true } : {}
+	};
+}
 function hasValidQueueOwnerRecordFields(record) {
 	return !Array.isArray(record) && 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);
 }
@@ -2199,15 +2366,20 @@ async function removeSocketFile(socketPath) {
 		if (error.code !== "ENOENT") throw error;
 	}
 }
-async function waitForProcessExit(pid, timeoutMs) {
+async function waitForProcessExit(pid, timeoutMs, hasExited) {
 	const deadline = Date.now() + Math.max(0, timeoutMs);
 	while (Date.now() <= deadline) {
-		if (!isProcessAlive(pid)) return true;
+		if (hasExited(pid)) return true;
 		await waitMs(PROCESS_POLL_MS);
 	}
-	return !isProcessAlive(pid);
+	return hasExited(pid);
 }
 async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+	await withQueueLeaseMutation(sessionId, async () => {
+		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent);
+	});
+}
+async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent) {
 	if (!await isCurrent()) return;
 	await removeSocketFile(socketPath).catch(() => {});
 	if (!await isCurrent()) return;
@@ -2217,7 +2389,10 @@ async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
 }
 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));
+	return matchesQueueOwner(current, owner) && (!requireStale || isQueueOwnerHeartbeatStale(current));
+}
+function matchesQueueOwner(current, expected) {
+	return current?.sessionId === expected.sessionId && current.pid === expected.pid && current.ownerGeneration === expected.ownerGeneration;
 }
 function ownerIsAlive(owner) {
 	return owner.pid === process.pid || isProcessAlive(owner.pid);
@@ -2234,37 +2409,34 @@ async function readQueueOwnerRecord(sessionId) {
 }
 async function terminateProcess(pid, beforeSignal) {
 	if (!isProcessAlive(pid)) return false;
-	for (const [signal, graceMs] of [["SIGTERM", PROCESS_SIGTERM_GRACE_MS], ["SIGKILL", PROCESS_SIGKILL_GRACE_MS]]) {
+	return await terminateWithDispatch(pid, async (signal) => {
 		if (beforeSignal && !await beforeSignal(signal)) return false;
-		try {
-			process.kill(pid, signal);
-		} catch {
-			return false;
-		}
-		if (await waitForProcessExit(pid, graceMs)) return true;
+		return dispatchSignal(pid, signal);
+	}, (target) => !isProcessAlive(target));
+}
+function dispatchSignal(pid, signal) {
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function terminateWithDispatch(pid, dispatch, hasExited) {
+	for (const [signal, graceMs] of [["SIGTERM", PROCESS_SIGTERM_GRACE_MS], ["SIGKILL", PROCESS_SIGKILL_GRACE_MS]]) {
+		if (!await dispatch(signal)) return false;
+		if (await waitForProcessExit(pid, graceMs, hasExited)) return true;
 	}
 	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) {
+	await settlePendingQueueLeaseGuard(sessionId);
 	const observed = await readQueueOwnerRecord(sessionId);
-	if (!observed) return;
-	const owner = await resolveUsableQueueOwner(sessionId, observed);
-	if (!owner) return;
-	return {
-		pid: owner.pid,
-		socketPath: owner.socketPath,
-		heartbeatAt: owner.heartbeatAt,
-		ownerGeneration: owner.ownerGeneration,
-		queueDepth: owner.queueDepth,
-		alive: true,
-		stale: isQueueOwnerHeartbeatStale(owner)
-	};
+	if (!matchesQueueOwner(observed, owner)) return;
+	if (ownerIsAlive(observed) && !isQueueOwnerHeartbeatStale(observed)) return observed;
+	await terminateQueueOwnerForSession(sessionId, observed, true);
+	const current = await readQueueOwnerRecord(sessionId);
+	return matchesQueueOwner(current, observed) && ownerIsAlive(current) && !isQueueOwnerHeartbeatStale(current) ? current : void 0;
 }
 async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, nowIsoFactory = nowIso) {
 	const { mcpConfigPath, clock } = resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory);
@@ -2285,21 +2457,30 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 		updates: Promise.resolve(),
 		released: false
 	};
+	const reservation = {
+		pid: lease.pid,
+		sessionId,
+		ownerGeneration,
+		published: false
+	};
 	try {
-		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 lease;
+		return await withQueueLeaseMutation(sessionId, async () => {
+			await stageQueueOwnerRecord(lease, 0, clock, 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
+					});
+				}
+				reservation.published = true;
+			});
+			await removeSocketFile(socketPath).catch(() => {});
+			return lease;
+		}, reservation);
 	} catch (error) {
 		return await handleLeaseCollision(sessionId, error);
 	}
@@ -2324,18 +2505,20 @@ async function handleLeaseCollision(sessionId, error) {
 }
 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;
-	}
+	await withQueueLeaseMutation(sessionId, async () => {
+		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 cleanupGuardedQueueOwnerFiles(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 {
@@ -2358,8 +2541,11 @@ function resolveLeaseArguments(mcpConfigOrNowIsoFactory, nowIsoFactory) {
 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);
+		await withQueueLeaseMutation(lease.sessionId, async () => {
+			if (!await ownsQueueLease(lease)) return;
+			await stageQueueOwnerRecord(lease, options.queueDepth, nowIsoFactory, async (tempPath) => {
+				await fs$1.rename(tempPath, lease.lockPath);
+			});
 		});
 	});
 	lease.updates = update.catch(() => {});
@@ -2376,6 +2562,7 @@ async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 		queueDepth: Math.max(0, Math.round(queueDepth)),
 		sharedRuntime: true,
 		sessionWatch: true,
+		persistsControlState: true,
 		...lease.mcpConfigPath ? { mcpConfigPath: lease.mcpConfigPath } : {},
 		...lease.mcpConfigFingerprint ? { mcpConfigFingerprint: lease.mcpConfigFingerprint } : {}
 	}, null, 2);
@@ -2398,11 +2585,15 @@ async function releaseQueueOwnerLease(lease) {
 	await cleanupQueueOwnerFiles(lease.sessionId, lease.socketPath, () => ownsQueueLease(lease));
 }
 async function terminateQueueOwnerForSession(sessionId, expectedOwner, requireStale = false) {
+	await settlePendingQueueLeaseGuard(sessionId);
 	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));
+	if (owner.pid !== process.pid && isProcessAlive(owner.pid)) await terminateWithDispatch(owner.pid, (signal) => withQueueLeaseMutation(sessionId, async () => {
+		if (!await ownsQueueLease(owner, requireStale && signal === "SIGTERM")) return false;
+		return dispatchSignal(owner.pid, signal);
+	}), isProcessDefinitelyDead);
+	if (!isProcessDefinitelyDead(owner.pid)) return;
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, async () => isProcessDefinitelyDead(owner.pid) && await ownsQueueLease(owner));
 }
 async function waitMs(ms) {
 	await new Promise((resolve) => {
@@ -2456,7 +2647,12 @@ async function connectToQueueOwner(owner, maxAttempts = QUEUE_CONNECT_ATTEMPTS)
 }
 //#endregion
 //#region src/session/queue/ipc-health.ts
+async function isStillCurrent(owner) {
+	const current = await readQueueOwnerRecord(owner.sessionId);
+	return current?.pid === owner.pid && current.ownerGeneration === owner.ownerGeneration;
+}
 async function probeQueueOwnerHealth(sessionId) {
+	await settlePendingQueueLeaseGuard(sessionId);
 	const ownerRecord = await readQueueOwnerRecord(sessionId);
 	if (!ownerRecord) return {
 		sessionId,
@@ -2465,7 +2661,7 @@ async function probeQueueOwnerHealth(sessionId) {
 		socketReachable: false,
 		pidAlive: false
 	};
-	const owner = await readQueueOwnerStatus(sessionId);
+	const owner = await resolveUsableQueueOwner(sessionId, ownerRecord);
 	if (!owner) return {
 		sessionId,
 		hasLease: false,
@@ -2473,10 +2669,9 @@ async function probeQueueOwnerHealth(sessionId) {
 		socketReachable: false,
 		pidAlive: false
 	};
-	const pidAlive = owner.alive;
 	let socketReachable = false;
 	try {
-		const socket = await connectToQueueOwner(ownerRecord, 2);
+		const socket = await connectToQueueOwner(owner, 2);
 		if (socket) {
 			socketReachable = true;
 			if (!socket.destroyed) socket.end();
@@ -2484,12 +2679,19 @@ async function probeQueueOwnerHealth(sessionId) {
 	} catch {
 		socketReachable = false;
 	}
+	if (!await isStillCurrent(owner)) return {
+		sessionId,
+		hasLease: false,
+		healthy: false,
+		socketReachable: false,
+		pidAlive: false
+	};
 	return {
 		sessionId,
 		hasLease: true,
 		healthy: socketReachable,
 		socketReachable,
-		pidAlive,
+		pidAlive: true,
 		pid: owner.pid,
 		socketPath: owner.socketPath,
 		ownerGeneration: owner.ownerGeneration,
@@ -3051,6 +3253,12 @@ async function runQueueOwnerRequest(options) {
 			onAbort();
 			return;
 		}
+		try {
+			options.assertDispatch?.();
+		} catch (error) {
+			finishReject(error);
+			return;
+		}
 		try {
 			socket.write(`${requestLine}\n`);
 		} catch (error) {
@@ -3164,10 +3372,11 @@ async function submitToQueueOwner(owner, options) {
 		}
 	});
 }
-async function submitControlToQueueOwner(owner, request, isExpectedResponse) {
+async function submitControlToQueueOwner(owner, request, isExpectedResponse, assertDispatch) {
 	return await runQueueOwnerRequest({
 		owner,
 		request,
+		assertDispatch,
 		onMessage: (message, { state, resolve, reject }) => {
 			if (message.type === "error") {
 				reject(queueConnectionErrorFromOwner(message, false));
@@ -3209,25 +3418,25 @@ async function submitCancelToQueueOwner(owner, targetRequestId) {
 		...targetRequestId !== void 0 ? { targetRequestId } : {}
 	}, (message) => message.type === "cancel_result"))?.cancelled;
 }
-async function submitSetModeToQueueOwner(owner, modeId, timeoutMs) {
+async function submitSetModeToQueueOwner(owner, modeId, timeoutMs, assertDispatch) {
 	return await submitControlToQueueOwner(owner, {
 		type: "set_mode",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		modeId,
 		timeoutMs
-	}, (message) => message.type === "set_mode_result") ? true : void 0;
+	}, (message) => message.type === "set_mode_result", assertDispatch) ? true : void 0;
 }
-async function submitSetModelToQueueOwner(owner, modelId, timeoutMs) {
+async function submitSetModelToQueueOwner(owner, modelId, timeoutMs, assertDispatch) {
 	return await submitControlToQueueOwner(owner, {
 		type: "set_model",
 		requestId: randomUUID(),
 		ownerGeneration: owner.ownerGeneration,
 		modelId,
 		timeoutMs
-	}, (message) => message.type === "set_model_result");
+	}, (message) => message.type === "set_model_result", assertDispatch);
 }
-async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs) {
+async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs, assertDispatch) {
 	return (await submitControlToQueueOwner(owner, {
 		type: "set_config_option",
 		requestId: randomUUID(),
@@ -3235,7 +3444,7 @@ async function submitSetConfigOptionToQueueOwner(owner, configId, value, timeout
 		configId,
 		value,
 		timeoutMs
-	}, (message) => message.type === "set_config_option_result"))?.response;
+	}, (message) => message.type === "set_config_option_result", assertDispatch))?.response;
 }
 async function submitCloseSessionToQueueOwner(owner, timeoutMs) {
 	return (await submitControlToQueueOwner(owner, {
@@ -3317,34 +3526,42 @@ async function tryCancelOnRunningOwner(options) {
 		submit: (owner) => submitCancelToQueueOwner(owner, options.targetRequestId)
 	});
 }
-async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose) {
+async function withOwnerControlPersistence(owner, operation) {
+	const persistsControlState = owner.persistsControlState === true;
+	const value = await operation;
+	return value === void 0 ? void 0 : {
+		value,
+		persistsControlState
+	};
+}
+async function trySetModeOnRunningOwner(sessionId, modeId, timeoutMs, verbose, assertDispatch) {
 	return await tryControlOnRunningOwner({
 		sessionId,
 		verbose,
 		requestName: "set_mode",
 		logPrefix: "[acpx] requested session/set_mode on owner pid",
-		submit: (owner) => submitSetModeToQueueOwner(owner, modeId, timeoutMs)
+		submit: (owner) => withOwnerControlPersistence(owner, submitSetModeToQueueOwner(owner, modeId, timeoutMs, assertDispatch))
 	});
 }
-async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose) {
+async function trySetModelOnRunningOwner(sessionId, modelId, timeoutMs, verbose, assertDispatch) {
 	return await tryControlOnRunningOwner({
 		sessionId,
 		verbose,
 		requestName: "set_model",
 		logPrefix: "[acpx] requested a model config update on owner pid",
-		submit: (owner) => submitSetModelToQueueOwner(owner, modelId, timeoutMs)
+		submit: (owner) => withOwnerControlPersistence(owner, submitSetModelToQueueOwner(owner, modelId, timeoutMs, assertDispatch))
 	});
 }
-async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose) {
+async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, timeoutMs, verbose, assertDispatch) {
 	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)
+		submit: (owner) => withOwnerControlPersistence(owner, submitSetConfigOptionToQueueOwner(owner, configId, value, timeoutMs, assertDispatch))
 	});
 }
 //#endregion
-export { startPerfTimer as $, listSessions as A, AgentSpawnError as At, extractAgentSessionId as B, SessionModeReplayError as Bt, textPrompt as C, OUTPUT_ERROR_ORIGINS as Ct, findSession as D, SESSION_RECORD_SCHEMA as Dt, findGitRepositoryRoot as E, PERMISSION_POLICY_ACTIONS as Et, resolveSessionRecord as F, GeminiAcpStartupTimeoutError as Ft, watchSession as G, SESSION_JOURNAL_SCHEMA as H, SessionNotFoundError as Ht, writeSessionRecord as I, PermissionDeniedError as It, incrementPerfCounter as J, formatPerfMetric as K, assertPersistedKeyPolicy as L, PermissionPromptUnavailableError as Lt, normalizeName as M, AuthPolicyError as Mt, pruneSessions as N, ClaudeAcpSessionCreateTimeoutError as Nt, findSessionByDirectoryWalk as O, AcpxOperationalError as Ot, readSessionRecord as P, CopilotAcpUnsupportedError as Pt, setPerfGauge as Q, parseSessionRecord as R, QueueConnectionError as Rt, promptToDisplayText as S, OUTPUT_ERROR_CODES as St, absolutePath as T, PERMISSION_MODES as Tt, SessionJournalReader as U, SessionResumeRequiredError as Ut, normalizeAgentSessionId as V, SessionModelReplayError as Vt, SessionWatchError as W, UnsupportedPromptContentError as Wt, recordPerfDuration as X, measurePerf as Y, resetPerfMetrics as Z, waitMs as _, formatUnknownErrorMessage as _t, trySetModelOnRunningOwner as a, parsePermissionNotice as at, mergePromptSourceWithText as b, EXIT_CODES as bt, queueRequestExceedsLimit as c, defaultSessionEventLog as ct, readQueueOwnerRecord as d, sessionEventLockPath as dt, extractSessionUpdateNotification as et, refreshQueueOwnerLease as f, sessionEventSegmentPath as ft, tryAcquireQueueOwnerLease as g, extractAcpError as gt, terminateQueueOwnerForSession as h, isProcessAlive as ht, trySetModeOnRunningOwner as i, parseJsonRpcErrorMessage as it, listSessionsForAgent as j, AgentStartupError as jt, isoNow as k, AgentDisconnectedError as kt, parseQueueRequest as l, sessionBaseDir as lt, terminateProcess as m, writePrivateJsonFile as mt, tryCloseSessionOnRunningOwner as n, isAcpMessageObject as nt, trySubmitToRunningOwner as o, parsePromptStopReason as ot, releaseQueueOwnerLease as p, writePrivateFile as pt, getPerfMetricsSnapshot as q, trySetConfigOptionOnRunningOwner as r, isSessionUpdateNotification as rt, queueRequestByteLimit as s, DEFAULT_EVENT_SEGMENT_MAX_BYTES as st, tryCancelOnRunningOwner as t, isAcpJsonRpcMessage as tt, probeQueueOwnerHealth as u, sessionEventActivePath as ut, PromptInputValidationError as v, isAcpResourceNotFoundError as vt, DEFAULT_HISTORY_LIMIT as w, OUTPUT_FORMATS as wt, parsePromptSource as x, NON_INTERACTIVE_PERMISSION_POLICIES as xt, getUnsupportedPromptContentMessage as y, AUTH_POLICIES as yt, serializeSessionRecordForDisk as z, SessionConfigOptionReplayError as zt };
+export { setPerfGauge as $, isoNow as A, AcpxOperationalError as At, serializeSessionRecordForDisk as B, QueueConnectionError as Bt, promptToDisplayText as C, NON_INTERACTIVE_PERMISSION_POLICIES as Ct, findGitRepositoryRoot as D, PERMISSION_MODES as Dt, absolutePath as E, OUTPUT_FORMATS as Et, readSessionRecord as F, ClaudeAcpSessionCreateTimeoutError as Ft, SessionWatchError as G, SessionResumeRequiredError as Gt, normalizeAgentSessionId as H, SessionModeReplayError as Ht, resolveSessionRecord as I, CopilotAcpUnsupportedError as It, getPerfMetricsSnapshot as J, watchSession as K, UnsupportedPromptContentError as Kt, writeSessionRecord as L, GeminiAcpStartupTimeoutError as Lt, listSessionsForAgent as M, AgentSpawnError as Mt, normalizeName as N, AgentStartupError as Nt, findSession as O, PERMISSION_POLICY_ACTIONS as Ot, pruneSessions as P, AuthPolicyError as Pt, resetPerfMetrics as Q, assertPersistedKeyPolicy as R, PermissionDeniedError as Rt, parsePromptSource as S, EXIT_CODES as St, DEFAULT_HISTORY_LIMIT as T, OUTPUT_ERROR_ORIGINS as Tt, SESSION_JOURNAL_SCHEMA as U, SessionModelReplayError as Ut, extractAgentSessionId as V, SessionConfigOptionReplayError as Vt, SessionJournalReader as W, SessionNotFoundError as Wt, measurePerf as X, incrementPerfCounter as Y, recordPerfDuration as Z, waitMs as _, isProcessDefinitelyDead as _t, trySetModelOnRunningOwner as a, parseJsonRpcErrorMessage as at, getUnsupportedPromptContentMessage as b, isAcpResourceNotFoundError as bt, queueRequestExceedsLimit as c, DEFAULT_EVENT_SEGMENT_MAX_BYTES as ct, readQueueOwnerRecord as d, sessionEventActivePath as dt, startPerfTimer as et, refreshQueueOwnerLease as f, sessionEventLockPath as ft, tryAcquireQueueOwnerLease as g, isProcessAlive as gt, terminateQueueOwnerForSession as h, writePrivateJsonFile as ht, trySetModeOnRunningOwner as i, isSessionUpdateNotification as it, listSessions as j, AgentDisconnectedError as jt, findSessionByDirectoryWalk as k, SESSION_RECORD_SCHEMA as kt, parseQueueRequest as l, defaultSessionEventLog as lt, terminateProcess as m, writePrivateFile as mt, tryCloseSessionOnRunningOwner as n, isAcpJsonRpcMessage as nt, trySubmitToRunningOwner as o, parsePermissionNotice as ot, releaseQueueOwnerLease as p, sessionEventSegmentPath as pt, formatPerfMetric as q, trySetConfigOptionOnRunningOwner as r, isAcpMessageObject as rt, queueRequestByteLimit as s, parsePromptStopReason as st, tryCancelOnRunningOwner as t, extractSessionUpdateNotification as tt, probeQueueOwnerHealth as u, sessionBaseDir as ut, QueueLeaseGuardSettlementError as v, extractAcpError as vt, textPrompt as w, OUTPUT_ERROR_CODES as wt, mergePromptSourceWithText as x, AUTH_POLICIES as xt, PromptInputValidationError as y, formatUnknownErrorMessage as yt, parseSessionRecord as z, PermissionPromptUnavailableError as zt };
 
-//# sourceMappingURL=ipc-D3akHMEq.js.map
+//# sourceMappingURL=ipc-BJrvfNXr.js.map