acpx 0.17.1 → 0.19.0

package/dist/{ipc-D2rstexT.js → ipc-fMgj5vrO.js}

@@ -1,4 +1,4 @@
-import { n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-evUoJINz.js";
+import { M as runTimedExecFile, n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-Ct2yWPW7.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 {
@@ -216,6 +217,7 @@ const OUTPUT_ERROR_CODES = [
 	"TIMEOUT",
 	"PERMISSION_DENIED",
 	"PERMISSION_PROMPT_UNAVAILABLE",
+	"EXEC_DISABLED",
 	"RUNTIME",
 	"USAGE"
 ];
@@ -229,12 +231,12 @@ const SESSION_RECORD_SCHEMA = "acpx.session.v1";
 //#endregion
 //#region src/acp/error-shapes.ts
 const RESOURCE_NOT_FOUND_ACP_CODES = /* @__PURE__ */ new Set([-32001, -32002]);
-function asRecord$5(value) {
+function asRecord$4(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
 function toAcpErrorPayload(value) {
-	const record = asRecord$5(value);
+	const record = asRecord$4(value);
 	if (!record) return;
 	if (typeof record.code !== "number" || !Number.isFinite(record.code)) return;
 	if (typeof record.message !== "string" || record.message.length === 0) return;
@@ -248,7 +250,7 @@ function extractAcpErrorInternal(value, depth) {
 	if (depth > 5) return;
 	const direct = toAcpErrorPayload(value);
 	if (direct) return direct;
-	const record = asRecord$5(value);
+	const record = asRecord$4(value);
 	if (!record) return;
 	return extractNestedAcpError(record, depth);
 }
@@ -283,7 +285,7 @@ function hasSessionNotFoundHint(value, depth = 0) {
 	if (depth > 4) return false;
 	if (isSessionNotFoundText(value)) return true;
 	if (Array.isArray(value)) return value.some((entry) => hasSessionNotFoundHint(entry, depth + 1));
-	const record = asRecord$5(value);
+	const record = asRecord$4(value);
 	if (!record) return false;
 	return Object.values(record).some((entry) => hasSessionNotFoundHint(entry, depth + 1));
 }
@@ -310,6 +312,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() {
@@ -430,18 +441,18 @@ function defaultSessionEventLog(sessionId) {
 }
 //#endregion
 //#region src/acp/jsonrpc.ts
-function asRecord$4(value) {
+function asRecord$3(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
 	return value;
 }
 function isAcpMessageObject(value) {
-	return asRecord$4(value) !== null;
+	return asRecord$3(value) !== null;
 }
 function hasValidId(value) {
 	return value === null || typeof value === "string" || typeof value === "number" && Number.isFinite(value);
 }
 function isErrorObject(value) {
-	const record = asRecord$4(value);
+	const record = asRecord$3(value);
 	return !!record && typeof record.code === "number" && Number.isFinite(record.code) && typeof record.message === "string";
 }
 function hasResultOrError(value) {
@@ -466,7 +477,7 @@ function isJsonRpcResponse(value) {
 	return hasResultOrError(value);
 }
 function isAcpJsonRpcMessage(value) {
-	const record = asRecord$4(value);
+	const record = asRecord$3(value);
 	if (!record || record.jsonrpc !== "2.0") return false;
 	return isJsonRpcNotificationRecord(record) || isJsonRpcRequest(record) || isJsonRpcResponse(record);
 }
@@ -476,14 +487,29 @@ function isJsonRpcNotification(message) {
 function isSessionUpdateNotification(message) {
 	return isJsonRpcNotification(message) && message.method === "session/update";
 }
+function sessionUpdateHasRequiredFields(update) {
+	const kind = update.sessionUpdate;
+	if (typeof kind !== "string") return false;
+	if (kind === "agent_message_chunk" || kind === "agent_thought_chunk" || kind === "user_message_chunk") return isChunkContent(update.content);
+	if (kind === "plan") return Array.isArray(update.entries) && update.entries.every(isPlanEntry);
+	return true;
+}
+function isChunkContent(value) {
+	const content = asRecord$3(value);
+	return content !== null && typeof content.type === "string" && (content.type !== "text" || typeof content.text === "string");
+}
+function isPlanEntry(value) {
+	const entry = asRecord$3(value);
+	return entry !== null && typeof entry.status === "string" && typeof entry.content === "string";
+}
 function extractSessionUpdateNotification(message) {
 	if (!isSessionUpdateNotification(message)) return;
-	const params = asRecord$4(message.params);
+	const params = asRecord$3(message.params);
 	if (!params) return;
 	const sessionId = typeof params.sessionId === "string" ? params.sessionId : null;
 	if (!sessionId) return;
-	const update = asRecord$4(params.update);
-	if (!update || typeof update.sessionUpdate !== "string") return;
+	const update = asRecord$3(params.update);
+	if (!update || !sessionUpdateHasRequiredFields(update)) return;
 	return {
 		sessionId,
 		update
@@ -491,18 +517,18 @@ function extractSessionUpdateNotification(message) {
 }
 function parsePromptStopReason(message) {
 	if (!Object.hasOwn(message, "id") || !Object.hasOwn(message, "result")) return;
-	const record = asRecord$4(message.result);
+	const record = asRecord$3(message.result);
 	if (!record) return;
 	return typeof record.stopReason === "string" ? record.stopReason : void 0;
 }
 function parsePermissionNotice(message) {
 	if (!Object.hasOwn(message, "id") || !Object.hasOwn(message, "result")) return;
-	const notice = asRecord$4(asRecord$4(asRecord$4(message.result)?._meta)?.acpx)?.permissionNotice;
+	const notice = asRecord$3(asRecord$3(asRecord$3(message.result)?._meta)?.acpx)?.permissionNotice;
 	return typeof notice === "string" ? notice : void 0;
 }
 function parseJsonRpcErrorMessage(message) {
 	if (!Object.hasOwn(message, "error")) return;
-	const errorRecord = asRecord$4(message.error);
+	const errorRecord = asRecord$3(message.error);
 	if (!errorRecord || typeof errorRecord.message !== "string") return;
 	return errorRecord.message;
 }
@@ -1098,7 +1124,7 @@ function resolveAgentArgvForCommand(agentCommand) {
 }
 //#endregion
 //#region src/session/persistence/parse.ts
-function asRecord$3(value) {
+function asRecord$2(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return;
 	return value;
 }
@@ -1117,12 +1143,12 @@ function parsePersistedAgentArgv(record) {
 function hasModelConfigOption(options) {
 	if (!Array.isArray(options)) return false;
 	return options.some((entry) => {
-		const option = asRecord$3(entry);
+		const option = asRecord$2(entry);
 		return option?.category === "model" || option?.id === "model";
 	});
 }
 function parseConfigOptions(raw) {
-	if (!Array.isArray(raw) || !raw.every((entry) => asRecord$3(entry) !== void 0)) return;
+	if (!Array.isArray(raw) || !raw.every((entry) => asRecord$2(entry) !== void 0)) return;
 	return raw;
 }
 function parseAvailableCommand(raw) {
@@ -1130,7 +1156,7 @@ function parseAvailableCommand(raw) {
 		const name = raw.trim();
 		return name ? { name } : void 0;
 	}
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return;
 	const name = parseNonEmptyString$1(record.name);
 	if (!name) return;
@@ -1153,7 +1179,7 @@ function parseNonEmptyString$1(value) {
 }
 function parseTokenUsage(raw) {
 	if (raw === void 0 || raw === null) return;
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return null;
 	const usage = {};
 	for (const field of [
@@ -1176,7 +1202,7 @@ function isNonNegativeFiniteNumber(value) {
 }
 function parseUsageCost(raw) {
 	if (raw === void 0 || raw === null) return;
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return null;
 	return parseUsageCostRecord(record);
 }
@@ -1202,7 +1228,7 @@ function parseCostCurrency(value) {
 }
 function parseRequestTokenUsage(raw) {
 	if (raw === void 0 || raw === null) return;
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return null;
 	const usage = {};
 	for (const [key, value] of Object.entries(record)) {
@@ -1213,25 +1239,25 @@ function parseRequestTokenUsage(raw) {
 	return usage;
 }
 function isSessionMessageImage(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record || typeof record.source !== "string") return false;
 	if (record.size === void 0 || record.size === null) return true;
-	const size = asRecord$3(record.size);
+	const size = asRecord$2(record.size);
 	return !!size && isFiniteNumber(size.width) && isFiniteNumber(size.height);
 }
 function isSessionMessageAudio(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	return !!record && typeof record.source === "string" && typeof record.mime_type === "string";
 }
 function isFiniteNumber(value) {
 	return typeof value === "number" && Number.isFinite(value);
 }
 function isUserContent(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return false;
 	if (typeof record.Text === "string") return true;
 	if (record.Mention !== void 0) {
-		const mention = asRecord$3(record.Mention);
+		const mention = asRecord$2(record.Mention);
 		return !!mention && typeof mention.uri === "string" && typeof mention.content === "string";
 	}
 	if (record.Image !== void 0) return isSessionMessageImage(record.Image);
@@ -1239,7 +1265,7 @@ function isUserContent(raw) {
 	return false;
 }
 function isToolUse(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	return !!record && hasStringFields$1(record, [
 		"id",
 		"name",
@@ -1253,18 +1279,18 @@ function isOptionalString(value) {
 	return value === void 0 || value === null || typeof value === "string";
 }
 function isToolResultContent(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return false;
 	if (typeof record.Text === "string") return true;
 	if (record.Image !== void 0) return isSessionMessageImage(record.Image);
 	return false;
 }
 function isToolResult(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	return !!record && typeof record.tool_use_id === "string" && typeof record.tool_name === "string" && typeof record.is_error === "boolean" && isToolResultContent(record.content);
 }
 function isAgentContent(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return false;
 	if (typeof record.Text === "string") return true;
 	if (record.Thinking !== void 0) return isThinkingContent(record.Thinking);
@@ -1273,21 +1299,21 @@ function isAgentContent(raw) {
 	return false;
 }
 function isThinkingContent(raw) {
-	const thinking = asRecord$3(raw);
+	const thinking = asRecord$2(raw);
 	return !!thinking && typeof thinking.text === "string" && isOptionalString(thinking.signature);
 }
 function isUserMessage(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record || record.User === void 0) return false;
-	const user = asRecord$3(record.User);
+	const user = asRecord$2(record.User);
 	return !!user && typeof user.id === "string" && Array.isArray(user.content) && user.content.every((entry) => isUserContent(entry));
 }
 function isAgentMessage(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record || record.Agent === void 0) return false;
-	const agent = asRecord$3(record.Agent);
+	const agent = asRecord$2(record.Agent);
 	if (!agent || !Array.isArray(agent.content) || !agent.content.every(isAgentContent)) return false;
-	const toolResults = asRecord$3(agent.tool_results);
+	const toolResults = asRecord$2(agent.tool_results);
 	if (!toolResults) return false;
 	return Object.values(toolResults).every(isToolResult);
 }
@@ -1320,7 +1346,7 @@ function hasValidConversationCore(record) {
 	return Array.isArray(record.messages) && record.messages.every(isConversationMessage) && typeof record.updated_at === "string";
 }
 function parseAcpxState(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return;
 	const state = {};
 	if (record.reset_on_next_ensure === true) state.reset_on_next_ensure = true;
@@ -1348,13 +1374,13 @@ function assignStringState(state, key, value) {
 	if (typeof value === "string") state[key] = value;
 }
 function parseStringMap(raw, preserveEmpty = false) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return;
 	const parsed = Object.fromEntries(Object.entries(record).filter((entry) => typeof entry[1] === "string"));
 	return Object.keys(parsed).length > 0 || preserveEmpty ? parsed : void 0;
 }
 function assignParsedSessionOptions(state, raw) {
-	const sessionOptions = asRecord$3(raw);
+	const sessionOptions = asRecord$2(raw);
 	if (!sessionOptions) return;
 	const parsedSessionOptions = {};
 	if (typeof sessionOptions.model === "string") parsedSessionOptions.model = sessionOptions.model;
@@ -1370,11 +1396,11 @@ function assignSessionOptionSystemPrompt(options, value) {
 		options.system_prompt = value;
 		return;
 	}
-	const appendRecord = asRecord$3(value);
+	const appendRecord = asRecord$2(value);
 	if (appendRecord && typeof appendRecord.append === "string" && appendRecord.append.length > 0) options.system_prompt = { append: appendRecord.append };
 }
 function parseEventLog(raw, sessionId) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record || !hasValidEventLogCore(record)) return defaultSessionEventLog(sessionId);
 	return {
 		active_path: record.active_path,
@@ -1393,7 +1419,7 @@ function isPositiveInteger$1(value) {
 }
 function parseImportedFrom(raw) {
 	if (raw == null) return;
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record || typeof record.record_id !== "string" || typeof record.cwd_original !== "string" || typeof record.exported_by !== "string" || typeof record.exported_at !== "string") return null;
 	return {
 		recordId: record.record_id,
@@ -1443,7 +1469,7 @@ function normalizeOptionalSignal(value) {
 	return Symbol("invalid");
 }
 function parseSessionRecord(raw) {
-	const record = asRecord$3(raw);
+	const record = asRecord$2(raw);
 	if (!record) return null;
 	if (record.schema !== "acpx.session.v1") return null;
 	const optionals = validSessionOptionals({
@@ -1488,7 +1514,7 @@ function parseSessionRecord(raw) {
 		lastAgentExitAt: optionals.lastAgentExitAt,
 		lastAgentDisconnectReason: optionals.lastAgentDisconnectReason,
 		protocolVersion: typeof record.protocol_version === "number" ? record.protocol_version : void 0,
-		agentCapabilities: asRecord$3(record.agent_capabilities),
+		agentCapabilities: asRecord$2(record.agent_capabilities),
 		title: conversation.title,
 		messages: conversation.messages,
 		updated_at: conversation.updated_at,
@@ -1601,111 +1627,28 @@ function assertPersistedKeyPolicy(value) {
 	throw new Error(`Persisted key policy violation (expected snake_case keys): ${violations.join(", ")}`);
 }
 //#endregion
-//#region src/session/persistence/index.ts
-const SESSION_INDEX_SCHEMA = "acpx.session-index.v1";
-function asRecord$2(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return;
-	return value;
-}
-function parseIndexEntry(raw) {
-	const record = asRecord$2(raw);
-	if (!record) return;
-	if (!hasRequiredIndexEntryFields(record)) return;
-	if (record.name !== void 0 && typeof record.name !== "string") return;
-	return {
-		file: record.file,
-		acpxRecordId: record.acpxRecordId,
-		acpSessionId: record.acpSessionId,
-		agentCommand: record.agentCommand,
-		cwd: record.cwd,
-		name: record.name,
-		closed: record.closed,
-		lastUsedAt: record.lastUsedAt
-	};
-}
-function hasRequiredIndexEntryFields(record) {
-	return [
-		"file",
-		"acpxRecordId",
-		"acpSessionId",
-		"agentCommand",
-		"cwd",
-		"lastUsedAt"
-	].every((key) => typeof record[key] === "string") && typeof record.closed === "boolean";
-}
-function sessionIndexPath(sessionDir) {
-	return path.join(sessionDir, "index.json");
-}
-function toSessionIndexEntry(record, fileName) {
-	return {
-		file: fileName,
-		acpxRecordId: record.acpxRecordId,
-		acpSessionId: record.acpSessionId,
-		agentCommand: record.agentCommand,
-		cwd: record.cwd,
-		name: record.name,
-		closed: record.closed === true,
-		lastUsedAt: record.lastUsedAt
-	};
+//#region src/session/persistence/discovery.ts
+const DISCOVERY_BATCH_SIZE = 4;
+/** Select and return the same canonical snapshot; cached metadata cannot exclude records. */
+async function* scanSessionRecords(sessionDir) {
+	const files = (await fs$1.readdir(sessionDir, { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	})).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name !== "index.json").map((entry) => entry.name).toSorted();
+	for (let offset = 0; offset < files.length; offset += DISCOVERY_BATCH_SIZE) {
+		const records = await Promise.all(files.slice(offset, offset + DISCOVERY_BATCH_SIZE).map((file) => readRecord(path.join(sessionDir, file))));
+		for (const record of records) if (record) yield record;
+	}
 }
-async function readSessionIndex(sessionDir) {
-	const filePath = sessionIndexPath(sessionDir);
+async function readRecord(file) {
 	try {
-		const payload = await fs$1.readFile(filePath, "utf8");
-		const record = asRecord$2(JSON.parse(payload));
-		if (!record || record.schema !== SESSION_INDEX_SCHEMA || !Array.isArray(record.files)) return;
-		const files = record.files.filter((entry) => typeof entry === "string");
-		if (files.length !== record.files.length || !Array.isArray(record.entries)) return;
-		const entries = record.entries.map((entry) => parseIndexEntry(entry)).filter((entry) => Boolean(entry));
-		if (entries.length !== record.entries.length) return;
-		return {
-			schema: SESSION_INDEX_SCHEMA,
-			files,
-			entries
-		};
+		const payload = await fs$1.readFile(file, "utf8");
+		const record = parseSessionRecord(JSON.parse(payload));
+		return record && path.basename(file) === `${safeSessionId(record.acpxRecordId)}.json` ? record : void 0;
 	} catch {
 		return;
 	}
 }
-async function writeSessionIndex(sessionDir, index) {
-	await writePrivateJsonFile(sessionIndexPath(sessionDir), {
-		schema: SESSION_INDEX_SCHEMA,
-		files: index.files.toSorted(),
-		entries: index.entries.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))
-	});
-}
-async function rebuildSessionIndex(sessionDir) {
-	const index = await scanSessionIndex(sessionDir);
-	await writeSessionIndex(sessionDir, index);
-	return index;
-}
-async function scanSessionIndex(sessionDir) {
-	const files = await listSessionFiles(sessionDir).catch((error) => {
-		if (error.code === "ENOENT") return [];
-		throw error;
-	});
-	const indexEntries = [];
-	for (const file of files) try {
-		const payload = await fs$1.readFile(path.join(sessionDir, file), "utf8");
-		const parsed = parseSessionRecord(JSON.parse(payload));
-		if (!parsed) continue;
-		indexEntries.push(toSessionIndexEntry(parsed, file));
-	} catch {}
-	return {
-		schema: SESSION_INDEX_SCHEMA,
-		files,
-		entries: indexEntries.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt))
-	};
-}
-async function loadOrRebuildSessionIndex(sessionDir) {
-	const files = await listSessionFiles(sessionDir);
-	const existing = await readSessionIndex(sessionDir);
-	if (existing && existing.files.length === files.length && existing.files.every((file, index) => file === files[index])) return existing;
-	return await rebuildSessionIndex(sessionDir);
-}
-async function listSessionFiles(sessionDir) {
-	return (await fs$1.readdir(sessionDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name !== "index.json").map((entry) => entry.name).toSorted();
-}
 //#endregion
 //#region src/session/persistence/repository.ts
 const DEFAULT_HISTORY_LIMIT = 20;
@@ -1719,62 +1662,56 @@ async function ensureSessionDir() {
 		mode: 448
 	});
 }
-async function loadRecordFromIndexEntry(entry) {
-	try {
-		const payload = await fs$1.readFile(path.join(sessionBaseDir(), entry.file), "utf8");
-		return parseSessionRecord(JSON.parse(payload)) ?? void 0;
-	} catch {
-		return;
-	}
-}
-async function loadSessionIndexEntries(readOnly = false) {
+async function* sessionRecords(readOnly = false) {
 	if (!readOnly) await ensureSessionDir();
-	return (await measurePerf("session.index_load", async () => {
-		return await (readOnly ? scanSessionIndex : loadOrRebuildSessionIndex)(sessionBaseDir());
-	})).entries;
+	yield* scanSessionRecords(sessionBaseDir());
 }
-function matchesSessionEntry(session, normalizedCwd, normalizedName, includeClosed = false) {
-	if (session.cwd !== normalizedCwd) return false;
+function matchesSession(session, agentCommand, normalizedName, includeClosed = false) {
+	if (session.agentCommand !== agentCommand) return false;
 	if (!includeClosed && session.closed) return false;
 	if (normalizedName == null) return session.name == null;
 	return session.name === normalizedName;
 }
+function isNewer(record, previous) {
+	return !previous || record.lastUsedAt.localeCompare(previous.lastUsedAt) > 0;
+}
 async function writeSessionRecord(record) {
 	await measurePerf("session.write_record", async () => {
 		const persisted = serializeSessionRecordForDisk(record);
 		assertPersistedKeyPolicy(persisted);
-		const file = sessionFilePath(record.acpxRecordId);
-		await writePrivateJsonFile(file, persisted);
-		const sessionDir = sessionBaseDir();
-		const index = await loadOrRebuildSessionIndex(sessionDir);
-		const fileName = path.basename(file);
-		const entries = index.entries.filter((entry) => entry.file !== fileName);
-		entries.push(toSessionIndexEntry(record, fileName));
-		await writeSessionIndex(sessionDir, {
-			files: [.../* @__PURE__ */ new Set([...index.files.filter((entry) => entry !== fileName), fileName])],
-			entries
-		});
+		await writePrivateJsonFile(sessionFilePath(record.acpxRecordId), persisted);
 	});
 }
 async function resolveSessionRecord(sessionId) {
 	await ensureSessionDir();
 	try {
 		const directRecord = await measurePerf("session.resolve_direct", async () => await readSessionRecord(sessionId));
-		if (directRecord) return directRecord;
+		if (directRecord?.acpxRecordId === sessionId) return directRecord;
 	} catch {}
-	const entries = await loadSessionIndexEntries();
-	const exactEntries = entries.filter((entry) => entry.acpxRecordId === sessionId || entry.acpSessionId === sessionId);
-	const exactRecords = (await Promise.all(exactEntries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry));
+	const { exactRecords, suffixRecords } = await findSessionIdMatches(sessionId);
 	if (exactRecords.length === 1) return exactRecords[0];
 	if (exactRecords.length > 1) throw new SessionResolutionError(`Multiple sessions match id: ${sessionId}`);
-	const suffixEntries = entries.filter((entry) => entry.acpxRecordId.endsWith(sessionId) || entry.acpSessionId.endsWith(sessionId));
-	const suffixRecords = (await Promise.all(suffixEntries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry));
 	if (suffixRecords.length === 1) return suffixRecords[0];
 	if (suffixRecords.length > 1) throw new SessionResolutionError(`Session id is ambiguous: ${sessionId}`);
 	incrementPerfCounter("session.resolve_miss");
 	throw new SessionNotFoundError(sessionId);
 }
-/** Reads a canonical record without creating directories or rebuilding the lookup index. */
+async function findSessionIdMatches(sessionId) {
+	const exactRecords = [];
+	const suffixRecords = [];
+	for await (const record of sessionRecords()) {
+		if (record.acpxRecordId === sessionId || record.acpSessionId === sessionId) retainMatch(exactRecords, record);
+		if (record.acpxRecordId.endsWith(sessionId) || record.acpSessionId.endsWith(sessionId)) retainMatch(suffixRecords, record);
+	}
+	return {
+		exactRecords,
+		suffixRecords
+	};
+}
+function retainMatch(matches, record) {
+	if (matches.length < 2) matches.push(record);
+}
+/** Reads one canonical record without creating directories or scanning other sessions. */
 async function readSessionRecord(sessionId) {
 	let payload;
 	try {
@@ -1784,7 +1721,8 @@ async function readSessionRecord(sessionId) {
 		throw error;
 	}
 	try {
-		return parseSessionRecord(JSON.parse(payload)) ?? void 0;
+		const record = parseSessionRecord(JSON.parse(payload));
+		return record?.acpxRecordId === sessionId ? record : void 0;
 	} catch {
 		return;
 	}
@@ -1824,42 +1762,49 @@ function isoNow() {
 	return (/* @__PURE__ */ new Date()).toISOString();
 }
 async function listSessions() {
-	await ensureSessionDir();
-	const entries = await loadSessionIndexEntries();
-	const records = [];
-	for (const entry of entries) {
-		const parsed = await loadRecordFromIndexEntry(entry);
-		if (parsed) records.push(parsed);
-	}
-	records.sort((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
-	return records;
+	return await collectSessionRecords();
 }
 async function listSessionsForAgent(agentCommand) {
-	const entries = (await loadSessionIndexEntries()).filter((session) => session.agentCommand === agentCommand);
-	return (await Promise.all(entries.map((entry) => loadRecordFromIndexEntry(entry)))).filter((entry) => Boolean(entry)).toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
+	return await collectSessionRecords(agentCommand);
+}
+async function collectSessionRecords(agentCommand) {
+	const records = [];
+	for await (const record of sessionRecords()) if (agentCommand === void 0 || record.agentCommand === agentCommand) records.push(record);
+	return records.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
 }
 async function findSession(options) {
 	const normalizedCwd = absolutePath(options.cwd);
 	const normalizedName = normalizeName(options.name);
-	const match = (await loadSessionIndexEntries(options.readOnly)).find((session) => session.agentCommand === options.agentCommand && matchesSessionEntry(session, normalizedCwd, normalizedName, options.includeClosed));
-	if (!match) return;
-	return await loadRecordFromIndexEntry(match);
+	let match;
+	for await (const record of sessionRecords(options.readOnly)) if (record.cwd === normalizedCwd && matchesSession(record, options.agentCommand, normalizedName, options.includeClosed) && isNewer(record, match)) match = record;
+	return match;
 }
 async function findSessionByDirectoryWalk(options) {
 	const normalizedName = normalizeName(options.name);
+	const directories = walkDirectories(options);
+	let match;
+	let distance = Infinity;
+	for await (const record of sessionRecords()) {
+		const candidateDistance = directories.get(record.cwd);
+		if (candidateDistance !== void 0 && matchesSession(record, options.agentCommand, normalizedName) && (candidateDistance < distance || candidateDistance === distance && isNewer(record, match))) {
+			match = record;
+			distance = candidateDistance;
+		}
+	}
+	return match;
+}
+function walkDirectories(options) {
 	const normalizedStart = absolutePath(options.cwd);
 	const normalizedBoundary = absolutePath(options.boundary ?? normalizedStart);
 	const walkBoundary = isWithinBoundary(normalizedBoundary, normalizedStart) ? normalizedBoundary : normalizedStart;
-	const sessions = (await loadSessionIndexEntries()).filter((session) => session.agentCommand === options.agentCommand);
+	const directories = /* @__PURE__ */ new Map();
+	const walkRoot = path.parse(normalizedStart).root;
 	let current = normalizedStart;
-	const walkRoot = path.parse(current).root;
-	for (;;) {
-		const match = sessions.find((session) => matchesSessionEntry(session, current, normalizedName));
-		if (match) return await loadRecordFromIndexEntry(match);
-		const parent = nextWalkParent(current, walkBoundary, walkRoot);
-		if (!parent) return;
-		current = parent;
+	while (current) {
+		directories.set(current, directories.size);
+		current = nextWalkParent(current, walkBoundary, walkRoot);
 	}
+	return directories;
 }
 function nextWalkParent(current, walkBoundary, walkRoot) {
 	if (current === walkBoundary || current === walkRoot) return;
@@ -1871,11 +1816,11 @@ 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(options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0), options.agentCommand);
 	if (options.dryRun) return {
 		pruned: records,
 		bytesFreed: 0,
@@ -1888,24 +1833,20 @@ async function pruneSessions(options = {}) {
 		dirEntries = await fs$1.readdir(sessionDir);
 	} catch {}
 	for (const record of records) bytesFreed += await pruneSessionFiles(record, sessionDir, dirEntries, options.includeHistory === true);
-	await rebuildSessionIndex(sessionDir).catch(() => {});
 	return {
 		pruned: records,
 		bytesFreed,
 		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(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);
-	}
-	return records;
+	for await (const record of sessionRecords()) if (isPruneCandidate(record, agentCommand) && isBeforeCutoff(record, cutoffIso)) records.push(record);
+	return records.toSorted((a, b) => b.lastUsedAt.localeCompare(a.lastUsedAt));
 }
 function isBeforeCutoff(record, cutoffIso) {
 	return !cutoffIso || closedAtOrLastUsedAt(record) < cutoffIso;
@@ -1963,12 +1904,12 @@ function isAudioBlock(value) {
 }
 function isResourceLinkBlock(value) {
 	const record = asRecord$1(value);
-	return record?.type === "resource_link" && isNonEmptyString(record.uri) && (record.title === void 0 || typeof record.title === "string") && (record.name === void 0 || typeof record.name === "string");
+	return record?.type === "resource_link" && isNonEmptyString(record.uri) && (record.title == null || typeof record.title === "string") && typeof record.name === "string";
 }
 function isResourcePayload(value) {
 	const record = asRecord$1(value);
 	if (!record || !isNonEmptyString(record.uri)) return false;
-	return record.text === void 0 || typeof record.text === "string";
+	return typeof record.text === "string" || typeof record.blob === "string";
 }
 function isResourceBlock(value) {
 	const record = asRecord$1(value);
@@ -2011,12 +1952,12 @@ function validateAudioContentBlock(record, index) {
 }
 function validateResourceLinkContentBlock(record, index) {
 	if (!isNonEmptyString(record.uri)) return `prompt[${index}] resource_link block must include a non-empty uri`;
-	if (record.title !== void 0 && typeof record.title !== "string") return `prompt[${index}] resource_link block title must be a string when present`;
-	if (record.name !== void 0 && typeof record.name !== "string") return `prompt[${index}] resource_link block name must be a string when present`;
+	if (record.title != null && typeof record.title !== "string") return `prompt[${index}] resource_link block title must be a string or null when present`;
+	if (typeof record.name !== "string") return `prompt[${index}] resource_link block must include a string name`;
 }
 function validateResourceContentBlock(record, index) {
 	if (!asRecord$1(record.resource)) return `prompt[${index}] resource block must include a resource object`;
-	return isResourcePayload(record.resource) ? void 0 : `prompt[${index}] resource block resource must include a non-empty uri and optional text`;
+	return isResourcePayload(record.resource) ? void 0 : `prompt[${index}] resource block resource must include a non-empty uri and a string text or blob field`;
 }
 function getContentBlockValidationError(value, index) {
 	const record = asRecord$1(value);
@@ -2101,6 +2042,318 @@ function resourceBlockDisplayText(block) {
 	return "text" in block.resource && typeof block.resource.text === "string" ? block.resource.text : block.resource.uri;
 }
 //#endregion
+//#region src/process-identity.ts
+const IDENTITY_QUERY_TIMEOUT_MS$1 = 2e3;
+const LINUX_PROCESS_QUERY = `
+  const fs = require('node:fs/promises');
+  const [targetPid, observerPid] = process.argv.slice(1);
+  if (process.ppid !== Number(observerPid)) process.exit(1);
+  const timeNamespace = (pid) => fs.readlink('/proc/' + pid + '/ns/time').catch((error) => {
+    if (error.code === 'ENOENT') return 'unsupported';
+    throw error;
+  });
+  Promise.all([
+    fs.readFile('/proc/sys/kernel/random/boot_id', 'utf8'),
+    fs.readlink('/proc/self/ns/pid'),
+    timeNamespace('self'),
+    fs.readlink('/proc/' + observerPid + '/ns/pid'),
+    timeNamespace(observerPid),
+    fs.readFile('/proc/self/stat', 'utf8'),
+    fs.readFile('/proc/' + targetPid + '/stat', 'utf8').catch(() => null),
+  ]).then(([bootId, pidNamespace, timeNamespace, observerPidNamespace,
+    observerTimeNamespace, selfStat, targetStat]) => {
+    process.stdout.write(JSON.stringify({bootId: bootId.trim(), pidNamespace,
+      timeNamespace, observerPidNamespace, observerTimeNamespace,
+      helperPid: process.pid, selfStat, targetStat}));
+  }).catch(() => { process.exitCode = 1; });
+`;
+const POSIX_MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec"
+];
+let ownIdentity;
+let ownIdentityPending;
+function parseProcessBirthIdentity(raw) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+	const identity = raw;
+	if (identity.kind === "linux-proc") return parseLinuxIdentity(identity);
+	if (identity.kind !== "posix-lstart" && identity.kind !== "windows-creation") return;
+	if (!isCanonicalBirth(identity.value, identity.kind)) return;
+	return {
+		kind: identity.kind,
+		value: identity.value
+	};
+}
+function isCanonicalBirth(value, kind) {
+	if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3,7}Z$/.test(value) || !Number.isFinite(Date.parse(value))) return false;
+	const canonical = new Date(value).toISOString();
+	return canonical.slice(0, 19) === value.slice(0, 19) && (kind === "posix-lstart" ? value === canonical && value.endsWith(".000Z") : /\.\d{7}Z$/.test(value));
+}
+function parseLinuxScope(raw) {
+	const { bootId, pidNamespace, timeNamespace } = raw;
+	if (typeof bootId !== "string" || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(bootId) || typeof pidNamespace !== "string" || !/^pid:\[[1-9]\d*\]$/.test(pidNamespace) || !isTimeNamespace(timeNamespace)) return;
+	return {
+		bootId,
+		pidNamespace,
+		timeNamespace
+	};
+}
+function isTimeNamespace(value) {
+	return typeof value === "string" && (value === "unsupported" || /^time:\[[1-9]\d*\]$/.test(value));
+}
+function isStartTicks(value) {
+	return typeof value === "string" && /^(?:0|[1-9]\d*)$/.test(value);
+}
+function parseLinuxIdentity(raw) {
+	const scope = parseLinuxScope(raw);
+	if (!scope || !isStartTicks(raw.startTicks)) return;
+	return {
+		kind: "linux-proc",
+		...scope,
+		startTicks: raw.startTicks
+	};
+}
+function compareLinuxScope(expected, observed) {
+	if (expected.bootId !== observed.bootId) return "different";
+	if (expected.pidNamespace !== observed.pidNamespace || expected.timeNamespace !== observed.timeNamespace) return "unknown";
+	return "matching";
+}
+function compareLinuxIdentity(expected, observed) {
+	const scope = compareLinuxScope(expected, observed);
+	return scope === "matching" ? expected.startTicks === observed.startTicks ? "matching" : "different" : scope;
+}
+function compareProcessBirthIdentity(expected, observed) {
+	if (!expected || expected.kind !== observed.kind) return "unknown";
+	if (expected.kind === "linux-proc" && observed.kind === "linux-proc") return compareLinuxIdentity(expected, observed);
+	if ("value" in expected && "value" in observed) return expected.value === observed.value ? "matching" : "different";
+	return "unknown";
+}
+function parseLinuxStat(raw) {
+	if (typeof raw !== "string") return;
+	const prefix = /^(\d+) \(/.exec(raw);
+	const close = raw.lastIndexOf(")");
+	if (!prefix || close < 0) return;
+	const pid = Number(prefix[1]);
+	const fields = raw.slice(close + 2).trim().split(/\s+/u);
+	const startTicks = fields[19];
+	if (!isPositivePid(pid) || !isStartTicks(startTicks) || !/^[RSDTtKWPI]$/.test(fields[0] ?? "")) return;
+	return {
+		pid,
+		startTicks
+	};
+}
+async function readLinuxObservation(pid, timeoutMs) {
+	const output = await runTimedExecFile(process.execPath, [
+		"--input-type=commonjs",
+		"-e",
+		LINUX_PROCESS_QUERY,
+		String(pid),
+		String(process.pid)
+	], {
+		timeoutMs,
+		maxBufferBytes: 8192,
+		env: {
+			...process.env,
+			NODE_OPTIONS: ""
+		}
+	});
+	const raw = JSON.parse(output);
+	const scope = parseLinuxScope(raw);
+	const self = parseLinuxStat(raw.selfStat);
+	if (!scope || !self || self.pid !== raw.helperPid || scope.pidNamespace !== raw.observerPidNamespace || scope.timeNamespace !== raw.observerTimeNamespace) return;
+	const target = parseLinuxStat(raw.targetStat);
+	return {
+		scope,
+		...target?.pid === pid ? { identity: {
+			kind: "linux-proc",
+			...scope,
+			startTicks: target.startTicks
+		} } : {}
+	};
+}
+function isPositivePid(pid) {
+	return Number.isSafeInteger(pid) && pid > 0;
+}
+function windowsPowerShellPath() {
+	const systemRoot = process.env.SystemRoot;
+	if (!systemRoot || !path.win32.isAbsolute(systemRoot)) throw new Error("Windows system directory is unavailable");
+	return path.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+function windowsProcessQuery(pid) {
+	return [
+		"$ErrorActionPreference = 'Stop'",
+		`Get-CimInstance -ClassName Win32_Process -Property ProcessId,ParentProcessId,CreationDate${pid === void 0 ? "" : ` -Filter 'ProcessId = ${pid}'`} | ForEach-Object {`,
+		"if ($null -ne $_.CreationDate) {",
+		"'{0} {1} 0 S {2}' -f $_.ProcessId,$_.ParentProcessId,$_.CreationDate.ToUniversalTime().ToString('o')",
+		"}",
+		"}"
+	].join("\n");
+}
+function posixBirth(value) {
+	const match = /^\w{3}\s+(\w{3})\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})$/.exec(value);
+	if (!match) return;
+	const month = POSIX_MONTHS.indexOf(match[1]);
+	if (month < 0) return;
+	const valueUtc = `${match[6]}-${String(month + 1).padStart(2, "0")}-${match[2].padStart(2, "0")}T${match[3]}:${match[4]}:${match[5]}.000Z`;
+	return isCanonicalBirth(valueUtc, "posix-lstart") ? valueUtc : void 0;
+}
+function parseProcessTable(output) {
+	const table = /* @__PURE__ */ new Map();
+	for (const line of output.split("\n")) {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.+?)\s*$/.exec(line);
+		if (!match || match[4].startsWith("Z")) continue;
+		const pid = Number(match[1]);
+		const birth = processTableBirth(match[5]);
+		if (Number.isSafeInteger(pid) && pid > 0 && birth) table.set(pid, {
+			pid,
+			parentPid: Number(match[2]),
+			groupPid: Number(match[3]),
+			birth
+		});
+	}
+	return table;
+}
+function processTableBirth(value) {
+	if (process.platform !== "win32") return posixBirth(value);
+	return isCanonicalBirth(value, "windows-creation") ? value : void 0;
+}
+async function readProcessTable(timeoutMs, pid) {
+	if (pid !== void 0 && (!Number.isSafeInteger(pid) || pid <= 0)) throw new Error("Process identity requires a positive PID");
+	if (process.platform === "win32") return parseProcessTable(await runTimedExecFile(windowsPowerShellPath(), [
+		"-NoLogo",
+		"-NoProfile",
+		"-NonInteractive",
+		"-Command",
+		windowsProcessQuery(pid)
+	], {
+		timeoutMs,
+		windowsHide: true
+	}));
+	return parseProcessTable(await runTimedExecFile("ps", [
+		...pid === void 0 ? ["-e"] : ["-p", String(pid)],
+		"-o",
+		"pid=,ppid=,pgid=,stat=,lstart="
+	], {
+		timeoutMs,
+		env: {
+			...process.env,
+			LC_ALL: "C",
+			TZ: "UTC"
+		}
+	}));
+}
+async function probeProcessIdentity(pid, timeoutMs = IDENTITY_QUERY_TIMEOUT_MS$1) {
+	if (!isPositivePid(pid)) return { state: "unknown" };
+	if (isProcessDefinitelyDead(pid)) return { state: "dead" };
+	try {
+		const identity = await readNativeIdentity(pid, timeoutMs);
+		if (identity) return {
+			state: "alive",
+			identity
+		};
+	} catch {}
+	return { state: isProcessDefinitelyDead(pid) ? "dead" : "unknown" };
+}
+async function readNativeIdentity(pid, timeoutMs) {
+	if (process.platform === "linux") return (await readLinuxObservation(pid, timeoutMs))?.identity;
+	const entry = (await readProcessTable(timeoutMs, pid)).get(pid);
+	return entry ? processBirthIdentity(entry.birth) : void 0;
+}
+function processBirthIdentity(value) {
+	return {
+		kind: process.platform === "win32" ? "windows-creation" : "posix-lstart",
+		value
+	};
+}
+function nativeIdentityKind() {
+	if (process.platform === "linux") return "linux-proc";
+	return process.platform === "win32" ? "windows-creation" : "posix-lstart";
+}
+function comparisonToIncarnation(comparison) {
+	return comparison === "different" ? "gone" : comparison;
+}
+async function observeLinuxIncarnation(pid, expected, timeoutMs) {
+	const observed = await readLinuxObservation(pid, timeoutMs).catch(() => void 0);
+	if (!observed) return "unknown";
+	const scope = compareLinuxScope(expected, observed.scope);
+	if (scope !== "matching") return comparisonToIncarnation(scope);
+	if (isProcessDefinitelyDead(pid)) return "gone";
+	return observed.identity ? comparisonToIncarnation(compareProcessBirthIdentity(expected, observed.identity)) : "unknown";
+}
+async function observeProcessIncarnation(pid, expected, timeoutMs = IDENTITY_QUERY_TIMEOUT_MS$1) {
+	if (!isPositivePid(pid)) return "unknown";
+	if (expected?.kind === "linux-proc") return process.platform === "linux" ? await observeLinuxIncarnation(pid, expected, timeoutMs) : "unknown";
+	if (expected && expected.kind !== nativeIdentityKind()) return "unknown";
+	return await observeTimestampIncarnation(pid, expected, timeoutMs);
+}
+async function observeTimestampIncarnation(pid, expected, timeoutMs) {
+	if (isProcessDefinitelyDead(pid)) return "gone";
+	if (!expected) return "unknown";
+	const observed = await probeProcessIdentity(pid, timeoutMs);
+	if (observed.state === "dead") return "gone";
+	return observed.state === "alive" ? comparisonToIncarnation(compareProcessBirthIdentity(expected, observed.identity)) : "unknown";
+}
+async function getOwnProcessIdentity() {
+	if (ownIdentity) return ownIdentity;
+	ownIdentityPending ??= probeProcessIdentity(process.pid).then((probe) => {
+		if (probe.state === "alive") ownIdentity = probe.identity;
+		return ownIdentity;
+	}).finally(() => {
+		ownIdentityPending = void 0;
+	});
+	return await ownIdentityPending;
+}
+//#endregion
+//#region src/session/lock-owner.ts
+const OBSERVATION_REUSE_MS = 1e3;
+const IDENTITY_QUERY_TIMEOUT_MS = 1e3;
+function lockOwnerPid(value) {
+	if (!value || typeof value !== "object" || !("pid" in value)) return;
+	const pid = value.pid;
+	return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function canReuseObservation(preserved, pid, identity, fresh) {
+	return !fresh && preserved?.pid === pid && compareProcessBirthIdentity(preserved.identity, identity) === "matching" && performance.now() - preserved.checkedAt < OBSERVATION_REUSE_MS;
+}
+async function createLockOwner(options = {}) {
+	const { signal, capturedIdentity } = options;
+	signal?.throwIfAborted();
+	const processIdentity = capturedIdentity === void 0 ? await getOwnProcessIdentity() : capturedIdentity.processIdentity;
+	signal?.throwIfAborted();
+	let preserved;
+	return {
+		payload: {
+			pid: process.pid,
+			processIdentity
+		},
+		async hasExited(payload, fresh, signal) {
+			signal?.throwIfAborted();
+			const pid = lockOwnerPid(payload);
+			if (!pid) return false;
+			const identity = parseProcessBirthIdentity(payload.processIdentity);
+			if (identity && canReuseObservation(preserved, pid, identity, fresh)) return false;
+			const incarnation = await observeProcessIncarnation(pid, identity, IDENTITY_QUERY_TIMEOUT_MS);
+			signal?.throwIfAborted();
+			if (identity && incarnation !== "gone") preserved = {
+				pid,
+				identity,
+				checkedAt: performance.now()
+			};
+			return incarnation === "gone";
+		}
+	};
+}
+//#endregion
 //#region src/session/queue/paths.ts
 function shortHash(value, length) {
 	return createHash("sha256").update(value).digest("hex").slice(0, length);
@@ -2124,6 +2377,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;
+	}
+}
+async function acquireGuard(lockPath, owner) {
+	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: () => owner.payload,
+		shouldReclaim: ({ payload }) => owner.hasExited(payload),
+		shouldRemoveStaleLock: ({ payload }) => owner.hasExited(payload, true)
+	});
+}
+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, receipt.owner);
+		}
+		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, options = {}) {
+	const { reservation, capturedIdentity } = options;
+	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 owner = await createLockOwner({ capturedIdentity });
+		const guard = await acquireGuard(lockPath, owner);
+		let outcome;
+		try {
+			outcome = {
+				ok: true,
+				value: await mutate()
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error
+			};
+		}
+		const published = publishedReservation();
+		const receipt = {
+			guard,
+			owner,
+			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;
@@ -2133,6 +2536,7 @@ function parseQueueOwnerRecord(raw) {
 	if (!raw || typeof raw !== "object") return null;
 	const record = raw;
 	if (!hasValidQueueOwnerRecordFields(record)) return null;
+	const processIdentity = parseProcessBirthIdentity(record.processIdentity);
 	return {
 		pid: record.pid,
 		sessionId: record.sessionId,
@@ -2141,12 +2545,19 @@ function parseQueueOwnerRecord(raw) {
 		heartbeatAt: record.heartbeatAt,
 		ownerGeneration: record.ownerGeneration,
 		queueDepth: record.queueDepth,
-		...record.sharedRuntime === true ? { sharedRuntime: true } : {},
-		...record.sessionWatch === true ? { sessionWatch: true } : {},
+		...processIdentity ? { processIdentity } : {},
+		...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 +2610,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) {
+async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent, capturedIdentity) {
+	await withQueueLeaseMutation(sessionId, async () => {
+		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent);
+	}, { capturedIdentity });
+}
+async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent) {
 	if (!await isCurrent()) return;
 	await removeSocketFile(socketPath).catch(() => {});
 	if (!await isCurrent()) return;
@@ -2215,9 +2631,11 @@ async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
 		if (error.code !== "ENOENT") throw error;
 	});
 }
-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));
+async function ownsQueueLease(owner) {
+	return matchesQueueOwner(await readQueueOwnerRecord(owner.sessionId), owner);
+}
+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,41 +2652,55 @@ 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 dispatchQueueOwnerSignal(pid, signal) {
+	if (process.platform !== "win32") return dispatchSignal(pid, signal);
+	const systemRoot = process.env.SystemRoot;
+	if (!systemRoot || !path.win32.isAbsolute(systemRoot)) throw new Error("Windows queue-owner cleanup requires an absolute SystemRoot directory");
+	const taskkill = path.win32.join(systemRoot, "System32", "taskkill.exe");
+	await runTimedExecFile(taskkill, [
+		"/pid",
+		String(pid),
+		"/T",
+		"/F"
+	], {
+		timeoutMs: PROCESS_SIGTERM_GRACE_MS,
+		windowsHide: true
+	});
+	return true;
+}
+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);
 	const mcpConfigMetadata = createMcpConfigMetadata(mcpConfigPath, readMcpConfigFingerprint(mcpConfigOrNowIsoFactory));
+	const processIdentity = await getOwnProcessIdentity();
 	await ensureQueueDir();
 	const lockPath = queueLockFilePath(sessionId);
 	const socketPath = queueSocketPath(sessionId);
@@ -2281,25 +2713,38 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 		socketPath,
 		createdAt,
 		ownerGeneration,
+		...processIdentity ? { processIdentity } : {},
 		...mcpConfigMetadata,
 		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
-				});
-			}
+		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,
+			capturedIdentity: lease
 		});
-		await removeSocketFile(socketPath).catch(() => {});
-		return lease;
 	} catch (error) {
 		return await handleLeaseCollision(sessionId, error);
 	}
@@ -2324,18 +2769,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,9 +2805,12 @@ 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);
+			});
+		}, { capturedIdentity: lease });
 	});
 	lease.updates = update.catch(() => {});
 	return update;
@@ -2373,9 +2823,11 @@ async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 		createdAt: lease.createdAt,
 		heartbeatAt: clock(),
 		ownerGeneration: lease.ownerGeneration,
+		...lease.processIdentity ? { processIdentity: lease.processIdentity } : {},
 		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);
@@ -2395,13 +2847,48 @@ async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 async function releaseQueueOwnerLease(lease) {
 	lease.released = true;
 	await lease.updates;
-	await cleanupQueueOwnerFiles(lease.sessionId, lease.socketPath, () => ownsQueueLease(lease));
+	await cleanupQueueOwnerFiles(lease.sessionId, lease.socketPath, () => ownsQueueLease(lease), lease);
+}
+function unverifiedQueueOwnerError(owner) {
+	return new QueueConnectionError(`Cannot safely retire queue owner pid ${owner.pid}: its process birth identity is unverified. Its lease was retained. Retry from the same local process namespace with process-query access, or let the owner finish normal shutdown or idle expiry.`, {
+		detailCode: "QUEUE_OWNER_IDENTITY_UNVERIFIED",
+		origin: "queue",
+		retryable: true
+	});
+}
+async function dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement) {
+	return await withQueueLeaseMutation(owner.sessionId, async () => {
+		const current = await readQueueOwnerRecord(owner.sessionId);
+		retirement.leaseReleased = current?.pid !== owner.pid;
+		if (!matchesQueueOwner(current, owner) || requireStale && signal === "SIGTERM" && !isQueueOwnerHeartbeatStale(current)) return false;
+		const identity = await observeProcessIncarnation(current.pid, current.processIdentity);
+		if (identity !== "matching") {
+			retirement.gone = identity === "gone";
+			retirement.unverified = identity === "unknown";
+			return false;
+		}
+		return await dispatchQueueOwnerSignal(owner.pid, signal);
+	});
+}
+async function retireQueueOwner(owner, requireStale) {
+	const deadline = performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
+	const retirement = {
+		gone: false,
+		unverified: false,
+		leaseReleased: false
+	};
+	await terminateWithDispatch(owner.pid, (signal) => dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement), isProcessDefinitelyDead);
+	if (retirement.unverified && requireStale) throw unverifiedQueueOwnerError(owner);
+	if (retirement.leaseReleased || retirement.unverified) await waitForProcessExit(owner.pid, Math.max(0, deadline - performance.now()), isProcessDefinitelyDead);
+	const gone = retirement.gone || await observeProcessIncarnation(owner.pid, owner.processIdentity) === "gone";
+	if (retirement.unverified && !gone) throw unverifiedQueueOwnerError(owner);
+	return gone;
 }
 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;
+	if (!owner || owner.sessionId !== sessionId || owner.pid === process.pid) return;
+	if (!await retireQueueOwner(owner, requireStale)) return;
 	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner));
 }
 async function waitMs(ms) {
@@ -2456,7 +2943,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 +2957,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 +2965,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 +2975,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 +3549,12 @@ async function runQueueOwnerRequest(options) {
 			onAbort();
 			return;
 		}
+		try {
+			options.assertDispatch?.();
+		} catch (error) {
+			finishReject(error);
+			return;
+		}
 		try {
 			socket.write(`${requestLine}\n`);
 		} catch (error) {
@@ -3164,10 +3668,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 +3714,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 +3740,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, {
@@ -3305,7 +3810,10 @@ async function tryCloseSessionOnRunningOwner(options) {
 		verbose: options.verbose,
 		requestName: "close_session",
 		logPrefix: "[acpx] requested session/close on active owner pid",
-		submit: (owner) => submitCloseSessionToQueueOwner(owner, options.timeoutMs)
+		submit: (owner) => {
+			options.onOwnerSelected?.(owner);
+			return submitCloseSessionToQueueOwner(owner, options.timeoutMs);
+		}
 	});
 }
 async function tryCancelOnRunningOwner(options) {
@@ -3317,34 +3825,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 { measurePerf as $, findGitRepositoryRoot as A, PERMISSION_POLICY_ACTIONS as At, writeSessionRecord as B, PermissionDeniedError as Bt, getUnsupportedPromptContentMessage as C, AUTH_POLICIES as Ct, textPrompt as D, OUTPUT_ERROR_ORIGINS as Dt, promptToDisplayText as E, OUTPUT_ERROR_CODES as Et, listSessionsForAgent as F, AgentStartupError as Ft, normalizeAgentSessionId as G, SessionModelReplayError as Gt, parseSessionRecord as H, QueueConnectionError as Ht, normalizeName as I, AuthPolicyError as It, SessionWatchError as J, UnsupportedPromptContentError as Jt, SESSION_JOURNAL_SCHEMA as K, SessionNotFoundError as Kt, pruneSessions as L, ClaudeAcpSessionCreateTimeoutError as Lt, findSessionByDirectoryWalk as M, AcpxOperationalError as Mt, isoNow as N, AgentDisconnectedError as Nt, DEFAULT_HISTORY_LIMIT as O, OUTPUT_FORMATS as Ot, listSessions as P, AgentSpawnError as Pt, incrementPerfCounter as Q, readSessionRecord as R, CopilotAcpUnsupportedError as Rt, PromptInputValidationError as S, isAcpResourceNotFoundError as St, parsePromptSource as T, NON_INTERACTIVE_PERMISSION_POLICIES as Tt, serializeSessionRecordForDisk as U, SessionConfigOptionReplayError as Ut, assertPersistedKeyPolicy as V, PermissionPromptUnavailableError as Vt, extractAgentSessionId as W, SessionModeReplayError as Wt, formatPerfMetric as X, watchSession as Y, getPerfMetricsSnapshot as Z, waitMs as _, writePrivateFile as _t, trySetModelOnRunningOwner as a, isAcpJsonRpcMessage as at, lockOwnerPid as b, extractAcpError as bt, queueRequestExceedsLimit as c, parseJsonRpcErrorMessage as ct, readQueueOwnerRecord as d, DEFAULT_EVENT_SEGMENT_MAX_BYTES as dt, recordPerfDuration as et, refreshQueueOwnerLease as f, defaultSessionEventLog as ft, tryAcquireQueueOwnerLease as g, sessionEventSegmentPath as gt, terminateQueueOwnerForSession as h, sessionEventLockPath as ht, trySetModeOnRunningOwner as i, extractSessionUpdateNotification as it, findSession as j, SESSION_RECORD_SCHEMA as jt, absolutePath as k, PERMISSION_MODES as kt, parseQueueRequest as l, parsePermissionNotice as lt, terminateProcess as m, sessionEventActivePath as mt, tryCloseSessionOnRunningOwner as n, setPerfGauge as nt, trySubmitToRunningOwner as o, isAcpMessageObject as ot, releaseQueueOwnerLease as p, sessionBaseDir as pt, SessionJournalReader as q, SessionResumeRequiredError as qt, trySetConfigOptionOnRunningOwner as r, startPerfTimer as rt, queueRequestByteLimit as s, isSessionUpdateNotification as st, tryCancelOnRunningOwner as t, resetPerfMetrics as tt, probeQueueOwnerHealth as u, parsePromptStopReason as ut, QueueLeaseGuardSettlementError as v, writePrivateJsonFile as vt, mergePromptSourceWithText as w, EXIT_CODES as wt, readProcessTable as x, formatUnknownErrorMessage as xt, createLockOwner as y, isProcessAlive as yt, resolveSessionRecord as z, GeminiAcpStartupTimeoutError as zt };
 
-//# sourceMappingURL=ipc-D2rstexT.js.map
+//# sourceMappingURL=ipc-fMgj5vrO.js.map