acpx 0.18.0 → 0.19.0

package/dist/{ipc-BJrvfNXr.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-DdKB-zia.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";
@@ -217,6 +217,7 @@ const OUTPUT_ERROR_CODES = [
 	"TIMEOUT",
 	"PERMISSION_DENIED",
 	"PERMISSION_PROMPT_UNAVAILABLE",
+	"EXEC_DISABLED",
 	"RUNTIME",
 	"USAGE"
 ];
@@ -230,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;
@@ -249,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);
 }
@@ -284,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));
 }
@@ -440,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) {
@@ -476,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);
 }
@@ -486,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
@@ -501,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;
 }
@@ -1108,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;
 }
@@ -1127,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) {
@@ -1140,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;
@@ -1163,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 [
@@ -1186,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);
 }
@@ -1212,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)) {
@@ -1223,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);
@@ -1249,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",
@@ -1263,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);
@@ -1283,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);
 }
@@ -1330,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;
@@ -1358,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;
@@ -1380,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,
@@ -1403,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,
@@ -1453,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({
@@ -1498,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,
@@ -1611,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;
@@ -1729,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 {
@@ -1794,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;
 	}
@@ -1834,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;
@@ -1885,8 +1820,7 @@ function isSessionStreamFile(fileName, safeId) {
 	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((await loadSessionIndexEntries()).filter((entry) => isPruneCandidate(entry, options.agentCommand)), options.before ?? (options.olderThanMs != null ? new Date(Date.now() - options.olderThanMs) : void 0), options.agentCommand);
+	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,
@@ -1899,7 +1833,6 @@ 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,
@@ -1909,14 +1842,11 @@ async function pruneSessions(options = {}) {
 function isPruneCandidate(record, agentCommand) {
 	return record.closed === true && (!agentCommand || record.agentCommand === agentCommand);
 }
-async function loadPrunableRecords(entries, cutoff, agentCommand) {
+async function loadPrunableRecords(cutoff, agentCommand) {
 	const records = [];
 	const cutoffIso = cutoff?.toISOString();
-	for (const entry of entries) {
-		const record = await loadRecordFromIndexEntry(entry);
-		if (record && isPruneCandidate(record, agentCommand) && 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;
@@ -1974,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);
@@ -2022,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);
@@ -2112,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);
@@ -2157,10 +2399,7 @@ async function canonicalLeasePath(sessionId) {
 		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) {
+async function acquireGuard(lockPath, owner) {
 	return await acquireFileLock(lockPath, {
 		managerKey: "acpx.queue-lease-mutation",
 		lockPath: `${lockPath}.guard`,
@@ -2173,9 +2412,9 @@ async function acquireGuard(lockPath) {
 			randomize: false
 		},
 		staleRecovery: "remove-if-unchanged",
-		payload: () => ({ pid: process.pid }),
-		shouldReclaim: guardOwnerHasExited,
-		shouldRemoveStaleLock: guardOwnerHasExited
+		payload: () => owner.payload,
+		shouldReclaim: ({ payload }) => owner.hasExited(payload),
+		shouldRemoveStaleLock: ({ payload }) => owner.hasExited(payload, true)
 	});
 }
 function matchesReservation(value, expected) {
@@ -2202,7 +2441,7 @@ async function settleReceipt(lockPath, receipt) {
 	if (receipt.reservation) {
 		if (!await receipt.guard.verifyStillHeld()) {
 			await receipt.guard.release();
-			receipt.guard = await acquireGuard(lockPath);
+			receipt.guard = await acquireGuard(lockPath, receipt.owner);
 		}
 		await rollbackReservation(lockPath, receipt.reservation);
 		receipt.reservation = void 0;
@@ -2241,7 +2480,8 @@ async function settlePendingQueueLeaseGuard(sessionId) {
 	if (!localMutations.has(lockPath)) return;
 	await locallySerialized(lockPath, async (state) => await settleFailedGuard(lockPath, state));
 }
-async function withQueueLeaseMutation(sessionId, mutate, reservation) {
+async function withQueueLeaseMutation(sessionId, mutate, options = {}) {
+	const { reservation, capturedIdentity } = options;
 	await fs$1.mkdir(path.dirname(queueLockFilePath(sessionId)), {
 		recursive: true,
 		mode: 448
@@ -2255,7 +2495,8 @@ async function withQueueLeaseMutation(sessionId, mutate, reservation) {
 	const publishedReservation = () => reservation?.published ? expected : void 0;
 	return await locallySerialized(lockPath, async (state) => {
 		await settleFailedGuard(lockPath, state);
-		const guard = await acquireGuard(lockPath);
+		const owner = await createLockOwner({ capturedIdentity });
+		const guard = await acquireGuard(lockPath, owner);
 		let outcome;
 		try {
 			outcome = {
@@ -2271,6 +2512,7 @@ async function withQueueLeaseMutation(sessionId, mutate, reservation) {
 		const published = publishedReservation();
 		const receipt = {
 			guard,
+			owner,
 			reservation: outcome.ok ? void 0 : published
 		};
 		try {
@@ -2294,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,
@@ -2302,6 +2545,7 @@ function parseQueueOwnerRecord(raw) {
 		heartbeatAt: record.heartbeatAt,
 		ownerGeneration: record.ownerGeneration,
 		queueDepth: record.queueDepth,
+		...processIdentity ? { processIdentity } : {},
 		...parseQueueOwnerCapabilities(record),
 		...typeof record.mcpConfigPath === "string" ? { mcpConfigPath: record.mcpConfigPath } : {},
 		...typeof record.mcpConfigFingerprint === "string" ? { mcpConfigFingerprint: record.mcpConfigFingerprint } : {}
@@ -2374,10 +2618,10 @@ async function waitForProcessExit(pid, timeoutMs, hasExited) {
 	}
 	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;
@@ -2387,9 +2631,8 @@ async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent) {
 		if (error.code !== "ENOENT") throw error;
 	});
 }
-async function ownsQueueLease(owner, requireStale = false) {
-	const current = await readQueueOwnerRecord(owner.sessionId);
-	return matchesQueueOwner(current, owner) && (!requireStale || 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;
@@ -2422,6 +2665,22 @@ function dispatchSignal(pid, signal) {
 		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;
@@ -2441,6 +2700,7 @@ async function resolveUsableQueueOwner(sessionId, owner) {
 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);
@@ -2453,6 +2713,7 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 		socketPath,
 		createdAt,
 		ownerGeneration,
+		...processIdentity ? { processIdentity } : {},
 		...mcpConfigMetadata,
 		updates: Promise.resolve(),
 		released: false
@@ -2480,7 +2741,10 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 			});
 			await removeSocketFile(socketPath).catch(() => {});
 			return lease;
-		}, reservation);
+		}, {
+			reservation,
+			capturedIdentity: lease
+		});
 	} catch (error) {
 		return await handleLeaseCollision(sessionId, error);
 	}
@@ -2546,7 +2810,7 @@ function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 			await stageQueueOwnerRecord(lease, options.queueDepth, nowIsoFactory, async (tempPath) => {
 				await fs$1.rename(tempPath, lease.lockPath);
 			});
-		});
+		}, { capturedIdentity: lease });
 	});
 	lease.updates = update.catch(() => {});
 	return update;
@@ -2559,6 +2823,7 @@ 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,
@@ -2582,18 +2847,49 @@ 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 (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));
+	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) {
 	await new Promise((resolve) => {
@@ -3514,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) {
@@ -3562,6 +3861,6 @@ async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, time
 	});
 }
 //#endregion
-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 };
+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-BJrvfNXr.js.map
+//# sourceMappingURL=ipc-fMgj5vrO.js.map