acpx 0.19.0 → 0.19.1

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

@@ -1,5 +1,5 @@
-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 { 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";
@@ -1727,17 +1727,18 @@ async function readSessionRecord(sessionId) {
 		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);
@@ -1746,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;
@@ -2052,6 +2053,39 @@ const LINUX_PROCESS_QUERY = `
     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'),
@@ -2059,12 +2093,12 @@ const LINUX_PROCESS_QUERY = `
     fs.readlink('/proc/' + observerPid + '/ns/pid'),
     timeNamespace(observerPid),
     fs.readFile('/proc/self/stat', 'utf8'),
-    fs.readFile('/proc/' + targetPid + '/stat', 'utf8').catch(() => null),
+    targets(),
   ]).then(([bootId, pidNamespace, timeNamespace, observerPidNamespace,
-    observerTimeNamespace, selfStat, targetStat]) => {
+    observerTimeNamespace, selfStat, target]) => {
     process.stdout.write(JSON.stringify({bootId: bootId.trim(), pidNamespace,
       timeNamespace, observerPidNamespace, observerTimeNamespace,
-      helperPid: process.pid, selfStat, targetStat}));
+      helperPid: process.pid, selfStat, ...target}));
   }).catch(() => { process.exitCode = 1; });
 `;
 const POSIX_MONTHS = [
@@ -2146,31 +2180,48 @@ function parseLinuxStat(raw) {
 	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 {
+	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;
 }
-async function readLinuxObservation(pid, timeoutMs) {
-	const output = await runTimedExecFile(process.execPath, [
+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: 8192,
+		maxBufferBytes: pid === "all" ? PROCESS_HELPER_MAX_BUFFER_BYTES : 8192,
 		env: {
 			...process.env,
 			NODE_OPTIONS: ""
 		}
 	});
-	const raw = JSON.parse(output);
+	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,
@@ -2181,6 +2232,80 @@ async function readLinuxObservation(pid, timeoutMs) {
 		} } : {}
 	};
 }
+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;
 }
@@ -2218,7 +2343,7 @@ function parseProcessTable(output) {
 			pid,
 			parentPid: Number(match[2]),
 			groupPid: Number(match[3]),
-			birth
+			birth: processBirthIdentity(birth)
 		});
 	}
 	return table;
@@ -2227,7 +2352,7 @@ function processTableBirth(value) {
 	if (process.platform !== "win32") return posixBirth(value);
 	return isCanonicalBirth(value, "windows-creation") ? value : void 0;
 }
-async function readProcessTable(timeoutMs, pid) {
+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",
@@ -2239,6 +2364,7 @@ async function readProcessTable(timeoutMs, 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",
@@ -2266,8 +2392,7 @@ async function probeProcessIdentity(pid, timeoutMs = IDENTITY_QUERY_TIMEOUT_MS$1
 }
 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;
+	return (await readProcessTable(timeoutMs, pid)).get(pid)?.birth;
 }
 function processBirthIdentity(value) {
 	return {
@@ -2314,6 +2439,138 @@ async function getOwnProcessIdentity() {
 	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;
@@ -2377,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();
@@ -2432,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;
 	}
@@ -2537,7 +2915,7 @@ function parseQueueOwnerRecord(raw) {
 	const record = raw;
 	if (!hasValidQueueOwnerRecordFields(record)) return null;
 	const processIdentity = parseProcessBirthIdentity(record.processIdentity);
-	return {
+	const owner = {
 		pid: record.pid,
 		sessionId: record.sessionId,
 		socketPath: record.socketPath,
@@ -2550,6 +2928,8 @@ function parseQueueOwnerRecord(raw) {
 		...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 {
@@ -2611,20 +2991,21 @@ 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, capturedIdentity) {
+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) => {
@@ -2640,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 {
@@ -2665,7 +3049,7 @@ function dispatchSignal(pid, signal) {
 		return false;
 	}
 }
-async function dispatchQueueOwnerSignal(pid, signal) {
+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");
@@ -2676,15 +3060,15 @@ async function dispatchQueueOwnerSignal(pid, signal) {
 		"/T",
 		"/F"
 	], {
-		timeoutMs: PROCESS_SIGTERM_GRACE_MS,
+		timeoutMs: retirementTimeRemaining(deadline, PROCESS_SIGTERM_GRACE_MS),
 		windowsHide: true
 	});
 	return true;
 }
-async function terminateWithDispatch(pid, dispatch, hasExited) {
+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;
 }
@@ -2692,10 +3076,10 @@ 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);
@@ -2806,9 +3190,13 @@ 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 });
 	});
@@ -2816,8 +3204,8 @@ function refreshQueueOwnerLease(lease, options, nowIsoFactory = nowIso) {
 	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,
@@ -2830,9 +3218,17 @@ async function stageQueueOwnerRecord(lease, queueDepth, clock, publish) {
 		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) => {
@@ -2856,40 +3252,120 @@ function unverifiedQueueOwnerError(owner) {
 		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) || requireStale && signal === "SIGTERM" && !isQueueOwnerHeartbeatStale(current)) return false;
-		const identity = await observeProcessIncarnation(current.pid, current.processIdentity);
+		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;
 		}
-		return await dispatchQueueOwnerSignal(owner.pid, signal);
+		if (process.platform === "win32" && !await prepareWindowsRetirement(current, retirement.deadline)) return false;
+		return await dispatchQueueOwnerSignal(owner.pid, signal, retirement.deadline);
 	});
 }
-async function retireQueueOwner(owner, requireStale) {
-	const deadline = performance.now() + PROCESS_SIGTERM_GRACE_MS + PROCESS_SIGKILL_GRACE_MS;
+async function retireQueueOwner(owner, requireStale, deadline) {
 	const retirement = {
 		gone: false,
 		unverified: false,
-		leaseReleased: false
+		leaseReleased: false,
+		deadline
 	};
-	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";
+	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 || owner.pid === process.pid) return;
-	if (!await retireQueueOwner(owner, requireStale)) return;
-	await cleanupQueueOwnerFiles(sessionId, owner.socketPath, () => ownsQueueLease(owner));
+	if (!owner || owner.sessionId !== sessionId) return;
+	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) => {
@@ -3294,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
 	};
 }
@@ -3578,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") {
@@ -3861,6 +4340,6 @@ async function trySetConfigOptionOnRunningOwner(sessionId, configId, value, time
 	});
 }
 //#endregion
-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 };
+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-fMgj5vrO.js.map
+//# sourceMappingURL=ipc-DAApJ5mi.js.map