acpx 0.18.0 → 0.19.1

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

@@ -1,5 +1,5 @@
-import { n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DdKB-zia.js";
-import { statSync } from "node:fs";
+import { C as PROCESS_HELPER_TIMEOUT_MS, E as isChildProcessRunning, N as runTimedExecFile, S as PROCESS_HELPER_MAX_BUFFER_BYTES, n as AGENT_REGISTRY, r as BUILT_IN_AGENT_PACKAGES, t as AGENT_ARGV_REGISTRY } from "./agent-registry-DWlx5BQ4.js";
+import fs, { statSync } from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
@@ -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,22 +1721,24 @@ 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;
 	}
 }
-function hasGitDirectory(dir) {
+function hasGitMarker(dir) {
 	const gitPath = path.join(dir, ".git");
 	try {
-		return statSync(gitPath).isDirectory();
+		const marker = statSync(gitPath);
+		return marker.isDirectory() || marker.isFile();
 	} catch {
 		return false;
 	}
 }
 function isWithinBoundary(boundary, target) {
 	const relative = path.relative(boundary, target);
-	return relative.length === 0 || !relative.startsWith("..") && !path.isAbsolute(relative);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
 }
 function absolutePath(value) {
 	return path.resolve(value);
@@ -1818,7 +1747,7 @@ function findGitRepositoryRoot(startDir) {
 	let current = absolutePath(startDir);
 	const root = path.parse(current).root;
 	for (;;) {
-		if (hasGitDirectory(current)) return current;
+		if (hasGitMarker(current)) return current;
 		if (current === root) return;
 		const parent = path.dirname(current);
 		if (parent === current) return;
@@ -1834,42 +1763,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 +1821,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 +1834,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 +1843,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 +1905,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 +1953,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 +2043,574 @@ 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;
+  });
+  const prefix = async (name, size) => {
+    const file = await fs.open(name, 'r');
+    try {
+      const buffer = Buffer.alloc(size);
+      const { bytesRead } = await file.read(buffer, 0, size, 0);
+      return buffer.subarray(0, bytesRead).toString('base64');
+    } finally { await file.close(); }
+  };
+  const targets = async () => {
+    if (targetPid !== 'all') {
+      return { targetStat: await fs.readFile('/proc/' + targetPid + '/stat', 'utf8').catch(() => null) };
+    }
+    const required = new Set(JSON.parse(process.argv[3] || '[]'));
+    const pids = new Set((await fs.readdir('/proc')).filter(pid => /^[1-9][0-9]*$/.test(pid)));
+    for (const pid of required) pids.add(String(pid));
+    const processStats = [];
+    let bytes = 0;
+    // Sequential reads keep proc I/O and retained memory bounded within this
+    // single killable helper; never launch one helper or pending read per PID.
+    for (const pid of [...pids].sort((a, b) => Number(a) - Number(b))) {
+      let stat;
+      try { stat = await fs.readFile('/proc/' + pid + '/stat', 'utf8'); }
+      catch (error) {
+        if (error.code === 'ENOENT' || error.code === 'ESRCH') continue;
+        if (!required.has(Number(pid)) && (error.code === 'EACCES' || error.code === 'EPERM')) continue;
+        throw error;
+      }
+      bytes += Buffer.byteLength(JSON.stringify(stat)) + 1;
+      if (bytes > ${PROCESS_HELPER_MAX_BUFFER_BYTES} - 8192) throw new Error('Process table exceeds its byte limit');
+      processStats.push(stat);
+    }
+    return { processStats, auxv: await prefix('/proc/self/auxv', 4096), elf: await prefix('/proc/self/exe', 6) };
+  };
+  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'),
+    targets(),
+  ]).then(([bootId, pidNamespace, timeNamespace, observerPidNamespace,
+    observerTimeNamespace, selfStat, target]) => {
+    process.stdout.write(JSON.stringify({bootId: bootId.trim(), pidNamespace,
+      timeNamespace, observerPidNamespace, observerTimeNamespace,
+      helperPid: process.pid, selfStat, ...target}));
+  }).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;
+	const parentPid = Number(fields[1]);
+	const groupPid = Number(fields[2]);
+	return validProcessLinks(parentPid, groupPid) ? {
+		pid,
+		parentPid,
+		groupPid,
+		startTicks
+	} : void 0;
+}
+function validProcessLinks(parentPid, groupPid) {
+	return Number.isSafeInteger(parentPid) && parentPid >= 0 && Number.isSafeInteger(groupPid) && groupPid >= 0;
+}
+async function readLinuxQuery(pid, timeoutMs, requiredPids = []) {
+	const args = [
+		"--input-type=commonjs",
+		"-e",
+		LINUX_PROCESS_QUERY,
+		String(pid),
+		String(process.pid)
+	];
+	if (pid === "all") args.push(JSON.stringify(requiredPids));
+	const output = await runTimedExecFile(process.execPath, args, {
+		timeoutMs,
+		maxBufferBytes: pid === "all" ? PROCESS_HELPER_MAX_BUFFER_BYTES : 8192,
+		env: {
+			...process.env,
+			NODE_OPTIONS: ""
+		}
+	});
+	return JSON.parse(output);
+}
+function verifiedLinuxScope(raw) {
+	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;
+	return scope;
+}
+async function readLinuxObservation(pid, timeoutMs) {
+	const raw = await readLinuxQuery(pid, timeoutMs);
+	const scope = verifiedLinuxScope(raw);
+	if (!scope) return;
+	const target = parseLinuxStat(raw.targetStat);
+	return {
+		scope,
+		...target?.pid === pid ? { identity: {
+			kind: "linux-proc",
+			...scope,
+			startTicks: target.startTicks
+		} } : {}
+	};
+}
+function linuxAuxv(raw) {
+	if (typeof raw.elf !== "string" || typeof raw.auxv !== "string") throw new Error("Linux process clock is unavailable");
+	const elf = Buffer.from(raw.elf, "base64");
+	const auxv = Buffer.from(raw.auxv, "base64");
+	if (elf.subarray(0, 4).toString("hex") !== "7f454c46" || ![1, 2].includes(elf[4]) || ![1, 2].includes(elf[5])) throw new Error("Linux process clock has an invalid ELF format");
+	return {
+		auxv,
+		size: elf[4] === 1 ? 4 : 8,
+		littleEndian: elf[5] === 1
+	};
+}
+function linuxClockTicks(raw) {
+	const { auxv, size, littleEndian } = linuxAuxv(raw);
+	const word = (offset) => readAuxvWord(auxv, offset, size, littleEndian);
+	for (let offset = 0; offset + size * 2 <= auxv.length; offset += size * 2) {
+		const key = word(offset);
+		if (key === 0n) break;
+		if (key === 17n && word(offset + size) > 0n) return word(offset + size);
+	}
+	throw new Error("Linux process clock has no AT_CLKTCK");
+}
+function readAuxvWord(buffer, offset, size, littleEndian) {
+	if (size === 8) return littleEndian ? buffer.readBigUInt64LE(offset) : buffer.readBigUInt64BE(offset);
+	return BigInt(littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset));
+}
+async function readLinuxProcessTable(timeoutMs, requiredPids, pid) {
+	const raw = await readLinuxQuery("all", timeoutMs, requiredPids);
+	const scope = verifiedLinuxScope(raw);
+	if (!scope || !Array.isArray(raw.processStats)) throw new Error("Linux process table scope is unverified");
+	const clockTicksPerSecond = linuxClockTicks(raw);
+	const table = /* @__PURE__ */ new Map();
+	for (const value of raw.processStats) {
+		const stat = parseLinuxStat(value);
+		if (stat && (pid === void 0 || stat.pid === pid)) table.set(stat.pid, {
+			pid: stat.pid,
+			parentPid: stat.parentPid,
+			groupPid: stat.groupPid,
+			birth: {
+				kind: "linux-proc",
+				...scope,
+				startTicks: stat.startTicks
+			},
+			clockTicksPerSecond
+		});
+	}
+	return table;
+}
+function readLinuxExitClock() {
+	let descriptor;
+	try {
+		descriptor = fs.openSync("/proc/uptime", "r");
+		const buffer = Buffer.alloc(64);
+		const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, 0);
+		const match = /^(\d+)\.(\d{2})\s/u.exec(buffer.toString("ascii", 0, bytes));
+		return match ? {
+			centiseconds: BigInt(match[1]) * 100n + BigInt(match[2]),
+			timeNamespace: readOwnTimeNamespace()
+		} : void 0;
+	} catch {
+		return;
+	} finally {
+		if (descriptor !== void 0) try {
+			fs.closeSync(descriptor);
+		} catch {}
+	}
+}
+function readOwnTimeNamespace() {
+	try {
+		return fs.readlinkSync("/proc/self/ns/time");
+	} catch (error) {
+		if (error.code === "ENOENT") return "unsupported";
+		throw error;
+	}
+}
+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: processBirthIdentity(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, requiredPids = []) {
+	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
+	}));
+	if (process.platform === "linux") return await readLinuxProcessTable(timeoutMs, requiredPids, pid);
+	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;
+	return (await readProcessTable(timeoutMs, pid)).get(pid)?.birth;
+}
+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/acp/process-descendants.ts
+function hasStaleWindowsParent(identity, parent) {
+	return identity.birth.kind === "windows-creation" && (parent?.birth.kind !== "windows-creation" || parent.birth.value > identity.birth.value);
+}
+function includeProcessDescendants(table, owned) {
+	let expanded;
+	do {
+		expanded = false;
+		for (const identity of table.values()) {
+			if (hasStaleWindowsParent(identity, table.get(identity.parentPid))) continue;
+			if (owned.has(identity.parentPid) && !owned.has(identity.pid)) {
+				owned.add(identity.pid);
+				expanded = true;
+			}
+		}
+	} while (expanded);
+}
+/** Best-effort cleanup for descendants witnessed during this child launch. */
+var ProcessDescendants = class {
+	child;
+	identities = /* @__PURE__ */ new Map();
+	rootBirth;
+	pending;
+	retired = false;
+	ownProcessGroup;
+	captureGroupAfterExit;
+	groupExitedAt;
+	onRootExit = () => {
+		this.groupExitedAt = process.platform === "linux" ? readLinuxExitClock() ?? null : Date.now();
+	};
+	constructor(child, options = {}) {
+		this.child = child;
+		this.ownProcessGroup = process.platform !== "win32" && Boolean(options.ownProcessGroup);
+		this.captureGroupAfterExit = this.ownProcessGroup && isChildProcessRunning(child);
+		if (this.ownProcessGroup) child.once("exit", this.onRootExit);
+	}
+	capture(timeoutMs = PROCESS_HELPER_TIMEOUT_MS) {
+		if (this.retired) return Promise.resolve(true);
+		this.pending ??= this.readSnapshot(timeoutMs).finally(() => {
+			this.pending = void 0;
+		});
+		return this.pending;
+	}
+	async readSnapshot(timeoutMs) {
+		const deadline = performance.now() + timeoutMs;
+		const rootWasRunning = isChildProcessRunning(this.child);
+		const captureRootGroup = rootWasRunning || this.captureGroupAfterExit;
+		if (!rootWasRunning) this.captureGroupAfterExit = false;
+		try {
+			const table = await readProcessTable(timeoutMs, void 0, this.requiredSnapshotPids(rootWasRunning));
+			if (!this.retired) {
+				table.delete(1);
+				table.delete(process.pid);
+				this.refresh(table, captureRootGroup);
+				if (this.captureGroupAfterExit && !isChildProcessRunning(this.child)) return await this.readSnapshot(Math.max(1, deadline - performance.now()));
+			}
+			return true;
+		} catch {
+			if (!isChildProcessRunning(this.child)) this.captureGroupAfterExit = false;
+			return false;
+		}
+	}
+	requiredSnapshotPids(rootWasRunning) {
+		return [...this.identities.keys(), ...rootWasRunning && this.child.pid ? [this.child.pid] : []];
+	}
+	refresh(table, rootWasRunning) {
+		this.verifyScope(table);
+		const owned = /* @__PURE__ */ new Set();
+		for (const [pid, identity] of this.identities) {
+			const observed = table.get(pid);
+			if (observed && compareProcessBirthIdentity(identity.birth, observed.birth) === "matching") owned.add(pid);
+		}
+		this.includeRoot(table, owned);
+		if (this.ownProcessGroup) this.includeProcessGroup(table, owned, rootWasRunning);
+		includeProcessDescendants(table, owned);
+		owned.delete(this.child.pid ?? 0);
+		this.identities = new Map([...table].filter(([pid]) => owned.has(pid)));
+	}
+	verifyScope(table) {
+		const expected = this.rootBirth ?? this.identities.values().next().value?.birth;
+		const observation = table.values().next().value?.birth;
+		if (expected && observation && compareProcessBirthIdentity(expected, observation) === "unknown") throw new Error("Descendant process scope changed");
+	}
+	includeRoot(table, owned) {
+		const root = this.child.pid;
+		const rootIdentity = root && table.get(root);
+		if (rootIdentity && isChildProcessRunning(this.child)) {
+			this.rootBirth ??= rootIdentity.birth;
+			if (compareProcessBirthIdentity(this.rootBirth, rootIdentity.birth) === "matching") owned.add(rootIdentity.pid);
+		}
+	}
+	includeProcessGroup(table, owned, rootWasRunning) {
+		const root = this.child.pid;
+		if (root && (rootWasRunning || [...owned].some((pid) => table.get(pid)?.groupPid === root))) {
+			for (const identity of table.values()) if (identity.groupPid === root && this.startedBeforeRootExit(identity)) owned.add(identity.pid);
+		}
+	}
+	startedBeforeRootExit(identity) {
+		const cutoff = this.groupExitedAt;
+		if (cutoff === void 0) return true;
+		if (cutoff === null) return false;
+		if (identity.birth.kind !== "linux-proc") return typeof cutoff === "number" && Date.parse(identity.birth.value) <= cutoff;
+		if (typeof cutoff === "number" || identity.birth.timeNamespace !== cutoff.timeNamespace || !identity.clockTicksPerSecond) return false;
+		return BigInt(identity.birth.startTicks) * 100n < (cutoff.centiseconds + 1n) * identity.clockTicksPerSecond;
+	}
+	async signal(signal, timeoutMs) {
+		if (!await this.capture(timeoutMs) || this.retired) return;
+		for (const pid of this.identities.keys()) try {
+			process.kill(pid, signal);
+		} catch {
+			this.identities.delete(pid);
+		}
+	}
+	hasTrackedProcesses() {
+		return this.identities.size > 0;
+	}
+	async waitForExit(timeoutMs) {
+		const deadline = performance.now() + timeoutMs;
+		do {
+			if (!await this.capture(Math.max(1, deadline - performance.now()))) return false;
+			if (this.identities.size === 0) return true;
+			await setTimeout$1(Math.min(100, Math.max(0, deadline - performance.now())));
+		} while (performance.now() < deadline);
+		return false;
+	}
+	retire() {
+		this.retired = true;
+		this.child.off("exit", this.onRootExit);
+		this.identities.clear();
+	}
+};
+//#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);
@@ -2135,6 +2634,127 @@ function queueSocketPath(sessionId, homeDir = os.homedir()) {
 	return path.join(queueSocketBaseDir(homeDir) ?? "/tmp", `${key}.sock`);
 }
 //#endregion
+//#region src/session/queue/retirement-receipt.ts
+const MAX_RETIREMENT_MEMBERS = 4096;
+const MAX_RETIREMENT_BYTES = 1048576;
+function hasQueueRetirementReceipt(value) {
+	return value !== null && typeof value === "object" && Object.hasOwn(value, "retirement");
+}
+function parseWitness(raw) {
+	if (!raw || typeof raw !== "object") return;
+	const value = raw;
+	const processIdentity = parseProcessBirthIdentity(value.processIdentity);
+	if (typeof value.pid !== "number" || !Number.isSafeInteger(value.pid) || value.pid <= 1 || processIdentity?.kind !== "windows-creation") return;
+	return {
+		pid: value.pid,
+		processIdentity
+	};
+}
+function parseQueueRetirementReceipt(raw, owner) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const value = raw;
+	const root = parseReceiptRoot(value, owner);
+	if (!root) return null;
+	const descendants = parseDescendants(value.descendants, root.pid);
+	if (!descendants) return null;
+	try {
+		if (Buffer.byteLength(JSON.stringify(raw)) > MAX_RETIREMENT_BYTES) return null;
+	} catch {
+		return null;
+	}
+	return {
+		ownerGeneration: owner.ownerGeneration,
+		root,
+		descendants
+	};
+}
+function parseReceiptRoot(value, owner) {
+	const root = parseWitness(value.root);
+	if (!root || root.pid !== owner.pid || value.ownerGeneration !== owner.ownerGeneration || compareProcessBirthIdentity(owner.processIdentity, root.processIdentity) !== "matching") return;
+	return root;
+}
+function parseDescendants(raw, rootPid) {
+	if (!Array.isArray(raw) || raw.length >= MAX_RETIREMENT_MEMBERS) return;
+	const pids = /* @__PURE__ */ new Set([rootPid]);
+	const witnesses = [];
+	for (const value of raw) {
+		const witness = parseWitness(value);
+		if (!witness || pids.has(witness.pid)) return;
+		pids.add(witness.pid);
+		witnesses.push(witness);
+	}
+	return witnesses;
+}
+function queueRetirementIncomplete() {
+	return new QueueConnectionError("Queue-owner descendant cleanup is incomplete or unverified. Its lease was retained. Retry cleanup with updated clients and process-query access; do not remove the lease while recorded processes may remain.", {
+		detailCode: "QUEUE_OWNER_RETIREMENT_INCOMPLETE",
+		origin: "queue",
+		retryable: true
+	});
+}
+function retirementTimeRemaining(deadline, maximumMs = 2e3) {
+	const remaining = deadline - performance.now();
+	if (remaining <= 0) throw queueRetirementIncomplete();
+	return Math.min(maximumMs, remaining);
+}
+async function captureQueueRetirementReceipt(owner, previous, rootRunning, deadline) {
+	const root = parseWitness({
+		pid: owner.pid,
+		processIdentity: owner.processIdentity
+	});
+	if (!root || process.platform !== "win32") throw queueRetirementIncomplete();
+	const table = await readProcessTable(retirementTimeRemaining(deadline)).catch(() => {
+		throw queueRetirementIncomplete();
+	});
+	const saved = unsettledSnapshotWitnesses(table, previous ? previous.descendants : []);
+	const owned = matchingSnapshotPids(table, rootRunning ? [root, ...saved] : saved);
+	if (rootRunning && !owned.has(root.pid)) throw queueRetirementIncomplete();
+	table.delete(1);
+	table.delete(process.pid);
+	includeProcessDescendants(table, owned);
+	owned.delete(root.pid);
+	const receipt = {
+		ownerGeneration: owner.ownerGeneration,
+		root,
+		descendants: mergeSnapshotDescendants(table, owned, saved)
+	};
+	if (!parseQueueRetirementReceipt(receipt, owner)) throw queueRetirementIncomplete();
+	return receipt;
+}
+function unsettledSnapshotWitnesses(table, witnesses) {
+	return witnesses.filter((witness) => {
+		const observed = table.get(witness.pid);
+		return !observed || compareProcessBirthIdentity(witness.processIdentity, observed.birth) !== "different";
+	});
+}
+function matchingSnapshotPids(table, witnesses) {
+	const owned = /* @__PURE__ */ new Set();
+	for (const witness of witnesses) {
+		const observed = table.get(witness.pid);
+		if (observed && compareProcessBirthIdentity(witness.processIdentity, observed.birth) === "matching") owned.add(witness.pid);
+	}
+	return owned;
+}
+function mergeSnapshotDescendants(table, owned, saved) {
+	const descendants = new Map(saved.map((witness) => [witness.pid, witness]));
+	for (const pid of owned) {
+		const observed = table.get(pid);
+		if (observed) descendants.set(pid, {
+			pid,
+			processIdentity: observed.birth
+		});
+	}
+	return [...descendants.values()];
+}
+async function observeRetirementWitness(witness, deadline) {
+	if (witness.pid === process.pid) throw queueRetirementIncomplete();
+	return await observeProcessIncarnation(witness.pid, witness.processIdentity, retirementTimeRemaining(deadline));
+}
+async function assertQueueRetirementComplete(receipt, deadline) {
+	if (receipt === null) throw queueRetirementIncomplete();
+	for (const witness of receipt?.descendants ?? []) if (await observeRetirementWitness(witness, deadline) !== "gone") throw queueRetirementIncomplete();
+}
+//#endregion
 //#region src/session/queue/lease-mutation.ts
 const GUARD_WAIT_MS = 2e3;
 const localMutations = /* @__PURE__ */ new Map();
@@ -2157,10 +2777,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 +2790,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) {
@@ -2193,7 +2810,7 @@ async function rollbackReservation(lockPath, expected) {
 		} catch {
 			return;
 		}
-		if (matchesReservation(value, expected)) await fs$1.unlink(lockPath);
+		if (matchesReservation(value, expected) && !hasQueueRetirementReceipt(value)) await fs$1.unlink(lockPath);
 	} catch (error) {
 		if (error.code !== "ENOENT") throw error;
 	}
@@ -2202,7 +2819,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 +2858,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 +2873,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 +2890,7 @@ async function withQueueLeaseMutation(sessionId, mutate, reservation) {
 		const published = publishedReservation();
 		const receipt = {
 			guard,
+			owner,
 			reservation: outcome.ok ? void 0 : published
 		};
 		try {
@@ -2294,7 +2914,8 @@ function parseQueueOwnerRecord(raw) {
 	if (!raw || typeof raw !== "object") return null;
 	const record = raw;
 	if (!hasValidQueueOwnerRecordFields(record)) return null;
-	return {
+	const processIdentity = parseProcessBirthIdentity(record.processIdentity);
+	const owner = {
 		pid: record.pid,
 		sessionId: record.sessionId,
 		socketPath: record.socketPath,
@@ -2302,10 +2923,13 @@ 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 } : {}
 	};
+	if (hasQueueRetirementReceipt(record)) owner.retirement = parseQueueRetirementReceipt(record.retirement, owner);
+	return owner;
 }
 function parseQueueOwnerCapabilities(record) {
 	return {
@@ -2367,29 +2991,29 @@ async function removeSocketFile(socketPath) {
 	}
 }
 async function waitForProcessExit(pid, timeoutMs, hasExited) {
-	const deadline = Date.now() + Math.max(0, timeoutMs);
-	while (Date.now() <= deadline) {
+	const deadline = performance.now() + Math.max(0, timeoutMs);
+	while (performance.now() <= deadline) {
 		if (hasExited(pid)) return true;
 		await waitMs(PROCESS_POLL_MS);
 	}
 	return hasExited(pid);
 }
-async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+async function cleanupQueueOwnerFiles(sessionId, socketPath, isCurrent, capturedIdentity, deadline = retirementDeadline()) {
 	await withQueueLeaseMutation(sessionId, async () => {
-		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent);
-	});
+		await cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent, deadline);
+	}, { capturedIdentity });
 }
-async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent) {
+async function cleanupGuardedQueueOwnerFiles(sessionId, socketPath, isCurrent, deadline = retirementDeadline()) {
 	if (!await isCurrent()) return;
+	await assertQueueRetirementComplete((await readQueueOwnerRecord(sessionId))?.retirement, deadline);
 	await removeSocketFile(socketPath).catch(() => {});
 	if (!await isCurrent()) return;
 	await fs$1.unlink(queueLockFilePath(sessionId)).catch((error) => {
 		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;
@@ -2397,6 +3021,9 @@ function matchesQueueOwner(current, expected) {
 function ownerIsAlive(owner) {
 	return owner.pid === process.pid || isProcessAlive(owner.pid);
 }
+function ownerAcceptsWork(owner) {
+	return owner.retirement === void 0 && ownerIsAlive(owner) && !isQueueOwnerHeartbeatStale(owner);
+}
 async function readQueueOwnerRecord(sessionId) {
 	const lockPath = queueLockFilePath(sessionId);
 	try {
@@ -2422,10 +3049,26 @@ function dispatchSignal(pid, signal) {
 		return false;
 	}
 }
-async function terminateWithDispatch(pid, dispatch, hasExited) {
+async function dispatchQueueOwnerSignal(pid, signal, deadline) {
+	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: retirementTimeRemaining(deadline, PROCESS_SIGTERM_GRACE_MS),
+		windowsHide: true
+	});
+	return true;
+}
+async function terminateWithDispatch(pid, dispatch, hasExited, deadline = Infinity) {
 	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;
+		if (await waitForProcessExit(pid, Math.min(graceMs, deadline - performance.now()), hasExited)) return true;
 	}
 	return false;
 }
@@ -2433,14 +3076,15 @@ async function resolveUsableQueueOwner(sessionId, owner) {
 	await settlePendingQueueLeaseGuard(sessionId);
 	const observed = await readQueueOwnerRecord(sessionId);
 	if (!matchesQueueOwner(observed, owner)) return;
-	if (ownerIsAlive(observed) && !isQueueOwnerHeartbeatStale(observed)) return observed;
+	if (ownerAcceptsWork(observed)) return observed;
 	await terminateQueueOwnerForSession(sessionId, observed, true);
 	const current = await readQueueOwnerRecord(sessionId);
-	return matchesQueueOwner(current, observed) && ownerIsAlive(current) && !isQueueOwnerHeartbeatStale(current) ? current : void 0;
+	return matchesQueueOwner(current, observed) && ownerAcceptsWork(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);
@@ -2453,6 +3097,7 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 		socketPath,
 		createdAt,
 		ownerGeneration,
+		...processIdentity ? { processIdentity } : {},
 		...mcpConfigMetadata,
 		updates: Promise.resolve(),
 		released: false
@@ -2480,7 +3125,10 @@ async function tryAcquireQueueOwnerLease(sessionId, mcpConfigOrNowIsoFactory, no
 			});
 			await removeSocketFile(socketPath).catch(() => {});
 			return lease;
-		}, reservation);
+		}, {
+			reservation,
+			capturedIdentity: lease
+		});
 	} catch (error) {
 		return await handleLeaseCollision(sessionId, error);
 	}
@@ -2542,32 +3190,45 @@ function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 	if (lease.released) return Promise.resolve();
 	const update = lease.updates.then(async () => {
 		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);
+			const current = await readQueueOwnerRecord(lease.sessionId);
+			if (!matchesQueueOwner(current, lease)) return;
+			if (current.retirement === null) throw queueRetirementIncomplete();
+			await replaceQueueOwnerRecord({
+				...current,
+				heartbeatAt: nowIsoFactory(),
+				queueDepth: Math.max(0, Math.round(options.queueDepth))
 			});
-		});
+		}, { capturedIdentity: lease });
 	});
 	lease.updates = update.catch(() => {});
 	return update;
 }
 async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
-	const payload = JSON.stringify({
-		pid: process.pid,
+	await stagePreparedQueueOwnerRecord({
+		pid: lease.pid,
 		sessionId: lease.sessionId,
 		socketPath: lease.socketPath,
 		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);
+	}, publish);
+}
+async function replaceQueueOwnerRecord(owner) {
+	await stagePreparedQueueOwnerRecord(owner, async (tempPath) => {
+		await fs$1.rename(tempPath, queueLockFilePath(owner.sessionId));
+	});
+}
+async function stagePreparedQueueOwnerRecord(owner, publish) {
+	const payload = JSON.stringify(owner, null, 2);
 	await withTempFile({
-		rootDir: path.dirname(lease.lockPath),
+		rootDir: path.dirname(queueLockFilePath(owner.sessionId)),
 		prefix: "owner",
 		fileName: "lease"
 	}, async (tempPath) => {
@@ -2582,18 +3243,129 @@ 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
+	});
+}
+function retirementDeadline() {
+	return performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
+}
+async function observeRetiringOwner(owner, deadline) {
+	return await observeProcessIncarnation(owner.pid, owner.processIdentity, process.platform === "win32" ? retirementTimeRemaining(deadline) : void 0);
+}
+function retirementBlockedByHeartbeat(owner, signal, requireStale) {
+	return requireStale && owner.retirement === void 0 && signal === "SIGTERM" && !isQueueOwnerHeartbeatStale(owner);
+}
+async function prepareWindowsRetirement(owner, deadline) {
+	if (owner.retirement === null) throw queueRetirementIncomplete();
+	owner.retirement = await captureQueueRetirementReceipt(owner, owner.retirement, true, deadline);
+	await replaceQueueOwnerRecord(owner);
+	return await observeRetirementWitness(owner.retirement.root, deadline) === "matching";
+}
+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) || retirementBlockedByHeartbeat(current, signal, requireStale)) return false;
+		if (current.retirement === null) throw queueRetirementIncomplete();
+		const identity = await observeRetiringOwner(current, retirement.deadline);
+		if (identity !== "matching") {
+			retirement.gone = identity === "gone";
+			retirement.unverified = identity === "unknown";
+			return false;
+		}
+		if (process.platform === "win32" && !await prepareWindowsRetirement(current, retirement.deadline)) return false;
+		return await dispatchQueueOwnerSignal(owner.pid, signal, retirement.deadline);
+	});
+}
+async function retireQueueOwner(owner, requireStale, deadline) {
+	const retirement = {
+		gone: false,
+		unverified: false,
+		leaseReleased: false,
+		deadline
+	};
+	await terminateWithDispatch(owner.pid, (signal) => dispatchVerifiedQueueOwnerSignal(owner, signal, requireStale, retirement), isProcessDefinitelyDead, process.platform === "win32" ? deadline : Infinity);
+	if (await waitForReleasedOwner(owner, requireStale, retirement)) return false;
+	const gone = retirement.gone || await observeRetiringOwner(owner, deadline) === "gone";
+	if (retirement.unverified && !gone) throw unverifiedQueueOwnerError(owner);
+	return gone;
+}
+async function waitForReleasedOwner(owner, requireStale, retirement) {
+	if (retirement.unverified && requireStale) throw unverifiedQueueOwnerError(owner);
+	if (retirement.leaseReleased || retirement.unverified) {
+		await waitForProcessExit(owner.pid, Math.max(0, retirement.deadline - performance.now()), isProcessDefinitelyDead);
+		if (performance.now() >= retirement.deadline) {
+			if (retirement.unverified) throw unverifiedQueueOwnerError(owner);
+			return true;
+		}
+	}
+	return false;
+}
+async function retireRecordedDescendants(owner, deadline) {
+	await withQueueLeaseMutation(owner.sessionId, async () => {
+		const current = await readQueueOwnerRecord(owner.sessionId);
+		if (!matchesQueueOwner(current, owner) || current.retirement === void 0) return;
+		if (current.retirement === null || process.platform !== "win32") throw queueRetirementIncomplete();
+		if (current.retirement.descendants.length === 0) return;
+		current.retirement = await captureQueueRetirementReceipt(current, current.retirement, false, deadline);
+		await replaceQueueOwnerRecord(current);
+		await signalRecordedDescendants(current.retirement, deadline);
+		await waitForRecordedDescendants(current.retirement, deadline);
+	});
+}
+async function hasSurvivingRetirementDescendant(receipt, deadline) {
+	for (const witness of receipt.descendants) {
+		const state = await observeRetirementWitness(witness, deadline);
+		if (state === "unknown") throw queueRetirementIncomplete();
+		if (state === "matching") return true;
+	}
+	return false;
+}
+async function signalRecordedDescendants(receipt, deadline) {
+	for (const witness of receipt.descendants) {
+		const state = await observeRetirementWitness(witness, deadline);
+		if (state === "unknown") throw queueRetirementIncomplete();
+		if (state === "matching") {
+			retirementTimeRemaining(deadline);
+			try {
+				process.kill(witness.pid, "SIGKILL");
+			} catch (error) {
+				if (await observeRetirementWitness(witness, deadline) !== "gone") throw error;
+			}
+		}
+	}
+}
+async function waitForRecordedDescendants(receipt, deadline) {
+	while (true) {
+		if (!await hasSurvivingRetirementDescendant(receipt, deadline)) return;
+		await waitMs(Math.min(1e3, retirementTimeRemaining(deadline)));
+	}
+}
+async function assertNoPendingRetirement(owner) {
+	const current = await readQueueOwnerRecord(owner.sessionId);
+	if (matchesQueueOwner(current, owner) && current.retirement !== void 0) throw queueRetirementIncomplete();
 }
 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.pid === process.pid) {
+		if (owner.retirement !== void 0) throw queueRetirementIncomplete();
+		return;
+	}
+	const deadline = retirementDeadline();
+	if (!await retireQueueOwner(owner, requireStale, deadline)) {
+		await assertNoPendingRetirement(owner);
+		return;
+	}
+	await retireRecordedDescendants(owner, deadline);
+	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner), void 0, deadline);
 }
 async function waitMs(ms) {
 	await new Promise((resolve) => {
@@ -2998,9 +3770,12 @@ function queueOwnerMessageParser(type) {
 }
 function parseEventOwnerMessage(message, context) {
 	if (!isAcpJsonRpcMessage(message.message)) return null;
+	const direction = message.direction;
+	if (direction !== void 0 && direction !== "inbound" && direction !== "outbound") return null;
 	return {
 		type: "event",
 		...context,
+		...direction === void 0 ? {} : { direction },
 		message: message.message
 	};
 }
@@ -3282,7 +4057,7 @@ function unexpectedQueueResponseError() {
 }
 function handleAcknowledgedSubmitMessage(message, controls, formatter) {
 	if (message.type === "event") {
-		notifyObserver(() => formatter.onAcpMessage(message.message));
+		notifyObserver(() => formatter.onAcpMessage(message.message, message.direction));
 		return;
 	}
 	if (message.type === "permission_escalation") {
@@ -3514,7 +4289,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 +4340,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, ProcessDescendants as x, formatUnknownErrorMessage as xt, createLockOwner as y, isProcessAlive as yt, resolveSessionRecord as z, GeminiAcpStartupTimeoutError as zt };
 
-//# sourceMappingURL=ipc-BJrvfNXr.js.map
+//# sourceMappingURL=ipc-DAApJ5mi.js.map