agent-yes 1.169.1 → 1.171.0

package/dist/notifyDaemon-BlGV0y4j.js

@@ -0,0 +1,591 @@
+import { n as logger } from "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-CoNr7tS8.js";
+import "./configShared-0MnIQ652.js";
+import { D as renderLogTailLines, G as hostId, J as readInbox, K as listInboxParents, Q as notifyDir, S as listRecords, U as appendEvent, W as gcInboxes, X as daemonLockDir, Y as shouldStealLock, Z as daemonLockOwnerPath, _ as isPidAlive, c as deriveLiveState, q as liveWatchers } from "./subcommands-CtWxwydR.js";
+import "./e2e-jb0Hp43q.js";
+import "./webrtcLink-B7REGtK2.js";
+import "./remotes-CC-4GuJb.js";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+
+//#region ts/notifyRouter.ts
+const DEFAULT_IDLE_CONFIRM_MS = 3e4;
+/**
+* Advance the router by one tick. Returns the notifications to push plus the
+* next RouterState. Only children with a numeric `parent_pid` are considered —
+* the caller is responsible for including only opted-in children.
+*
+* First-observation (baseline / startup-reconcile) semantics: a child we've
+* never seen that is ALREADY terminal emits immediately for `needs_input` /
+* `stopped`, and starts its idle timer at `now` for `idle` (so a child parked
+* idle when the daemon starts still notifies after the confirm window). To avoid
+* re-emitting the same baseline on every daemon restart, the caller SEEDS the
+* prior state from each inbox's already-written edges (see cmdNotifyd).
+*/
+function stepRouter(prev, observations, now, config = {}) {
+	const idleConfirmMs = config.idleConfirmMs ?? DEFAULT_IDLE_CONFIRM_MS;
+	const events = [];
+	const next = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const obs of observations) {
+		if (typeof obs.parent_pid !== "number" || obs.parent_pid <= 0) continue;
+		seen.add(obs.pid);
+		let p = prev.get(obs.pid);
+		if (p && obs.started_at != null && p.started_at != null && p.started_at !== obs.started_at) {
+			if (!p.exitedEmitted) events.push(syntheticExited(p, obs.pid));
+			p = void 0;
+		} else if (p && obs.started_at != null && p.started_at == null) p = void 0;
+		const cs = {
+			parent_pid: obs.parent_pid,
+			wrapper_pid: obs.wrapper_pid,
+			started_at: obs.started_at,
+			parent_started_at: obs.parent_started_at,
+			cli: obs.cli,
+			cwd: obs.cwd,
+			state: obs.state,
+			idleSince: p?.idleSince ?? null,
+			idleEmitted: p?.idleEmitted ?? false,
+			inNeedsInput: p?.inNeedsInput ?? false,
+			needsInputQuestion: p?.needsInputQuestion ?? null,
+			exitedEmitted: p?.exitedEmitted ?? false
+		};
+		const prevState = p?.state ?? null;
+		const emit = (edge) => events.push({
+			parent_pid: obs.parent_pid,
+			child_pid: obs.pid,
+			child_wrapper_pid: obs.wrapper_pid,
+			child_started_at: obs.started_at,
+			parent_started_at: obs.parent_started_at,
+			cli: obs.cli,
+			cwd: obs.cwd,
+			edge,
+			prev_state: prevState,
+			state: obs.state,
+			question: edge === "needs_input" ? obs.question : null
+		});
+		switch (obs.state) {
+			case "needs_input":
+				cs.idleSince = null;
+				cs.idleEmitted = false;
+				if (!cs.inNeedsInput || cs.needsInputQuestion !== obs.question) {
+					emit("needs_input");
+					cs.inNeedsInput = true;
+					cs.needsInputQuestion = obs.question;
+				}
+				break;
+			case "idle":
+				cs.inNeedsInput = false;
+				cs.needsInputQuestion = null;
+				if (p?.state === "idle" && p.idleSince != null) {
+					cs.idleSince = p.idleSince;
+					cs.idleEmitted = p.idleEmitted;
+				} else {
+					cs.idleSince = now;
+					cs.idleEmitted = false;
+				}
+				if (!cs.idleEmitted && now - (cs.idleSince ?? now) >= idleConfirmMs) {
+					emit("idle");
+					cs.idleEmitted = true;
+				}
+				break;
+			case "stopped":
+				cs.idleSince = null;
+				cs.idleEmitted = false;
+				cs.inNeedsInput = false;
+				cs.needsInputQuestion = null;
+				if (!cs.exitedEmitted) {
+					emit("exited");
+					cs.exitedEmitted = true;
+				}
+				break;
+			default:
+				cs.idleSince = null;
+				cs.idleEmitted = false;
+				cs.inNeedsInput = false;
+				cs.needsInputQuestion = null;
+				break;
+		}
+		next.set(obs.pid, cs);
+	}
+	for (const [pid, cs] of prev) {
+		if (seen.has(pid)) continue;
+		if (config.aliveChildStartedAt) {
+			const liveStart = config.aliveChildStartedAt.get(pid);
+			if (liveStart !== void 0 && (cs.started_at == null || liveStart === cs.started_at)) {
+				next.set(pid, cs);
+				continue;
+			}
+		}
+		if (!cs.exitedEmitted) events.push(syntheticExited(cs, pid));
+	}
+	return {
+		events,
+		next
+	};
+}
+/**
+* A synthetic `exited` for a child that left the live set without our observing
+* its stop — either reaped between ticks, or displaced by a pid-reuse. Built from
+* the last-known router state so it still carries the child's identity.
+*/
+function syntheticExited(cs, pid) {
+	return {
+		parent_pid: cs.parent_pid,
+		child_pid: pid,
+		child_wrapper_pid: cs.wrapper_pid,
+		child_started_at: cs.started_at,
+		parent_started_at: cs.parent_started_at,
+		cli: cs.cli,
+		cwd: cs.cwd,
+		edge: "exited",
+		prev_state: cs.state,
+		state: "stopped",
+		question: null
+	};
+}
+
+//#endregion
+//#region ts/notifyDaemon.ts
+/**
+* `ay notifyd` — the always-on-while-watched detection engine. Polls every
+* WATCHED agent's live state (the runtime-agnostic query layer, so BOTH Rust and
+* TS children are covered), runs the pure debounce router (`notifyRouter.ts`),
+* and appends the decided edges — enriched with a payload the parent can act on
+* without tailing — into each parent's inbox (`notifyStore.ts`).
+*
+* Lifecycle: a host singleton, guarded by an mkdir lock that records its owner
+* pid so a crashed daemon's stale lock is detected and STOLEN (never a permanent
+* deadlock). Scope + liveness are driven by the WATCHER REGISTRY: the daemon only
+* processes children whose parent is currently running `ay notify watch` (so an
+* unrelated agent never gets an inbox), and it stays alive as long as any watcher
+* heartbeat is live, self-exiting only after a grace window with no watchers.
+* `ay notify watch` re-ensures the daemon every poll, so a parent that watches
+* BEFORE spawning children (or across a fan-out gap) always has a live daemon.
+*/
+const POLL_MS = 2e3;
+const GC_EVERY_TICKS = 30;
+const IDLE_EXIT_GRACE_MS = 6e4;
+const LS_OPTS = {
+	all: true,
+	active: false,
+	json: false,
+	latest: false,
+	cwdScope: null
+};
+/** Short git HEAD of a cwd, best-effort, never blocks emission. */
+function gitHead(cwd) {
+	return new Promise((resolve) => {
+		execFile("git", [
+			"-C",
+			cwd,
+			"rev-parse",
+			"--short",
+			"HEAD"
+		], {
+			timeout: 1500,
+			windowsHide: true
+		}, (err, stdout) => resolve(err ? null : stdout.trim() || null));
+	});
+}
+/** Last few rendered log lines, compacted, so the parent needn't tail. */
+async function recentTail(logFile) {
+	if (!logFile) return null;
+	const lines = await renderLogTailLines(logFile, 12).catch(() => null);
+	if (!lines) return null;
+	const compact = lines.map((l) => l.replace(/\s+$/, "")).filter((l) => l.trim()).slice(-8);
+	return compact.length ? compact.join("\n").slice(0, 1200) : null;
+}
+/**
+* Seed the router's prior state from what each inbox has ALREADY recorded, so a
+* daemon restart does not re-emit a baseline the parent already saw.
+*
+* pid-reuse guard: seed a child ONLY if it is still in the registry with the
+* SAME start time as the inbox recorded (`liveChildren`: pid → started_at). A pid
+* whose live start time differs is a NEW child recycling the pid — seeding it
+* would suppress its first notification, so we skip it (it starts fresh). A pid
+* absent from the registry (reaped) is skipped too: it won't be observed again,
+* and if the pid is later reused, that new child was never seeded.
+*/
+async function reconcileFromInboxes(host, liveChildren, watchedParents) {
+	const state = /* @__PURE__ */ new Map();
+	for (const parent of await listInboxParents(host)) {
+		if (!watchedParents.has(parent)) continue;
+		const events = await readInbox(host, parent);
+		const lastByChild = /* @__PURE__ */ new Map();
+		for (const e of events) lastByChild.set(e.child_pid, e);
+		for (const [childPid, last] of lastByChild) {
+			const liveStarted = liveChildren.get(childPid);
+			if (liveStarted === void 0) continue;
+			if (!last.child_started_at || liveStarted !== last.child_started_at) continue;
+			const seededState = last.edge === "exited" ? "stopped" : last.edge === "needs_input" ? "needs_input" : last.edge === "idle" ? "idle" : "active";
+			state.set(childPid, {
+				parent_pid: last.parent_pid,
+				wrapper_pid: last.child_wrapper_pid,
+				started_at: last.child_started_at,
+				parent_started_at: last.parent_started_at,
+				cli: last.cli,
+				cwd: last.cwd,
+				state: seededState,
+				idleSince: null,
+				idleEmitted: false,
+				inNeedsInput: false,
+				needsInputQuestion: null,
+				exitedEmitted: last.edge === "exited"
+			});
+		}
+	}
+	return state;
+}
+/** Observe every child WHOSE PARENT IS WATCHING. Nothing else gets an inbox. */
+async function observeChildren() {
+	const watching = await liveWatchers();
+	const records = await listRecords(void 0, LS_OPTS);
+	const startedAtByWrapper = /* @__PURE__ */ new Map();
+	for (const r of records) if (typeof r.wrapper_pid === "number" && r.wrapper_pid > 0) startedAtByWrapper.set(r.wrapper_pid, r.started_at);
+	const obs = [];
+	const parentStartedAt = /* @__PURE__ */ new Map();
+	const childStartedAt = /* @__PURE__ */ new Map();
+	const logFiles = /* @__PURE__ */ new Map();
+	const aliveChildStartedAt = /* @__PURE__ */ new Map();
+	for (const r of records) if (typeof r.parent_pid === "number" && r.parent_pid > 0 && r.status !== "exited" && isPidAlive(r.pid)) aliveChildStartedAt.set(r.pid, r.started_at);
+	for (const r of records) {
+		const parent = r.parent_pid;
+		if (typeof parent !== "number" || parent <= 0) continue;
+		if (!watching.has(parent)) continue;
+		const watcherStart = watching.get(parent) ?? 0;
+		if (watcherStart > 0 && r.started_at < watcherStart) continue;
+		const { state, question } = await deriveLiveState(r);
+		const parentStart = watching.get(parent) || startedAtByWrapper.get(parent) || 0;
+		obs.push({
+			pid: r.pid,
+			wrapper_pid: r.wrapper_pid ?? void 0,
+			started_at: r.started_at,
+			parent_pid: parent,
+			parent_started_at: parentStart,
+			cli: r.cli,
+			cwd: r.cwd,
+			state,
+			question
+		});
+		parentStartedAt.set(r.pid, parentStart);
+		childStartedAt.set(r.pid, r.started_at);
+		logFiles.set(r.pid, r.log_file ?? null);
+	}
+	return {
+		obs,
+		parentStartedAt,
+		childStartedAt,
+		logFiles,
+		aliveChildStartedAt,
+		watcherCount: watching.size
+	};
+}
+/** Registry snapshot: every record's pid → its started_at (for reconcile guard). */
+async function liveChildrenSnapshot() {
+	const records = await listRecords(void 0, LS_OPTS).catch(() => []);
+	const m = /* @__PURE__ */ new Map();
+	for (const r of records) m.set(r.pid, r.started_at);
+	return m;
+}
+const OWNER_TTL_MS = 3e4;
+let daemonStartedAt = 0;
+let daemonToken = "";
+/** The token currently written in the daemon lock owner file, or null. */
+async function readDaemonOwnerToken() {
+	try {
+		return JSON.parse(await readFile(daemonLockOwnerPath(), "utf8")).token ?? null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Stamp the lock owner file with our identity + a fresh heartbeat ts + token,
+* ATOMICALLY (temp + rename) so a reader (status/stop/another daemon) never sees
+* a torn owner mid-write — a null read then reliably means "no owner file yet".
+*/
+async function writeOwner() {
+	const tmp = `${daemonLockOwnerPath()}.${daemonToken}.tmp`;
+	try {
+		await writeFile(tmp, JSON.stringify({
+			pid: process.pid,
+			started_at: daemonStartedAt,
+			ts: Date.now(),
+			token: daemonToken
+		}));
+		await rename(tmp, daemonLockOwnerPath());
+		return true;
+	} catch {
+		await rm(tmp, { force: true }).catch(() => {});
+		return false;
+	}
+}
+/**
+* Acquire the singleton lock. Returns true if WE now hold it, false if a LIVE
+* daemon already does. Shares the inbox lock's invariant: ownership is proven by
+* `mkdir(recursive:false)`, and a lock is stolen only when its owner is dead or
+* its heartbeat is stale — never on a torn/empty owner WITHIN the grace (the
+* mkdir→writeOwner window of another daemon coming up), so two concurrent starts
+* can't both "win". The liveness predicate is injectable for tests.
+*/
+async function acquireDaemonLock(isAlive = isPidAlive) {
+	await mkdir(notifyDir(), { recursive: true }).catch(() => {});
+	for (;;) try {
+		await mkdir(daemonLockDir(), { recursive: false });
+		daemonStartedAt = Date.now();
+		daemonToken = randomUUID();
+		if (!await writeOwner()) {
+			await rm(daemonLockDir(), {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await new Promise((r) => setTimeout(r, 15));
+			continue;
+		}
+		return true;
+	} catch (e) {
+		if (e.code !== "EEXIST") throw e;
+		const raw = await readFile(daemonLockOwnerPath(), "utf8").catch(() => "");
+		const now = Date.now();
+		let owner = null;
+		try {
+			owner = JSON.parse(raw);
+		} catch {}
+		if (owner && typeof owner.pid === "number" && owner.pid > 0 && owner.pid !== process.pid && typeof owner.ts === "number" && now - owner.ts <= OWNER_TTL_MS && isAlive(owner.pid)) return false;
+		if (shouldStealLock(raw, now, {
+			staleMs: OWNER_TTL_MS,
+			lockAgeMs: now - await stat(daemonLockDir()).then((s) => s.mtimeMs).catch(() => now),
+			selfPid: process.pid,
+			isAlive
+		})) {
+			await rm(daemonLockDir(), {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			continue;
+		}
+		await new Promise((r) => setTimeout(r, 15));
+	}
+}
+/**
+* Run the daemon loop in the FOREGROUND. `ay notifyd start` spawns this detached;
+* `ay notifyd run` runs it inline. Holds the host singleton lock for its lifetime.
+*/
+async function runDaemon(opts = {}) {
+	const host = hostId();
+	const intervalMs = opts.intervalMs ?? POLL_MS;
+	if (opts.once) {
+		if (await daemonStatus()) return 0;
+		const watched = new Set((await liveWatchers()).keys());
+		await tickState(host, await reconcileFromInboxes(host, await liveChildrenSnapshot(), watched));
+		return 0;
+	}
+	if (!await acquireDaemonLock()) {
+		logger.debug("[notifyd] another live daemon holds the lock — exiting");
+		return 0;
+	}
+	let running = true;
+	const ownerBeat = setInterval(() => {
+		(async () => {
+			if (await readDaemonOwnerToken() !== daemonToken) {
+				clearInterval(ownerBeat);
+				return;
+			}
+			await writeOwner();
+		})();
+	}, Math.max(1e3, Math.floor(OWNER_TTL_MS / 3)));
+	if (typeof ownerBeat.unref === "function") ownerBeat.unref();
+	const cleanup = async () => {
+		running = false;
+		clearInterval(ownerBeat);
+		if (await readDaemonOwnerToken() === daemonToken) await rm(daemonLockDir(), {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+	};
+	process.on("SIGINT", () => void cleanup().then(() => process.exit(0)));
+	process.on("SIGTERM", () => void cleanup().then(() => process.exit(0)));
+	const watchedAtStart = new Set((await liveWatchers()).keys());
+	let prev = await reconcileFromInboxes(host, await liveChildrenSnapshot(), watchedAtStart);
+	let ticks = 0;
+	let emptySince = null;
+	const pendingRetry = /* @__PURE__ */ new Map();
+	while (running) {
+		if (await readDaemonOwnerToken() !== daemonToken) {
+			logger.debug("[notifyd] lock lost/removed — exiting");
+			break;
+		}
+		const { next, watcherCount } = await tickState(host, prev, pendingRetry);
+		prev = next;
+		ticks++;
+		if (ticks % GC_EVERY_TICKS === 0) await gcTick(host).catch(() => {});
+		if (watcherCount > 0) emptySince = null;
+		else if (emptySince == null) emptySince = Date.now();
+		if (emptySince != null && Date.now() - emptySince > IDLE_EXIT_GRACE_MS) {
+			logger.debug("[notifyd] no watchers — exiting");
+			break;
+		}
+		await new Promise((r) => setTimeout(r, intervalMs));
+	}
+	await cleanup();
+	return 0;
+}
+/**
+* A durable-in-memory retry queue for edges whose append failed. Keyed by the
+* event's identity so a pid reused by a different child never collides (the key
+* includes child_started_at). The router state is NOT rolled back on failure —
+* re-delivery is owned entirely by this queue, so a failed OLD-child exited and
+* the NEW same-pid child's edges are retried independently (at-least-once per
+* event). Bounded so a permanently-unwritable inbox can't grow it without bound.
+*/
+const RETRY_CAP = 1e3;
+function retryKey(e) {
+	return `${e.parent_pid}:${e.child_pid}:${e.child_started_at ?? 0}:${e.edge}:${e.ts}`;
+}
+async function tickState(host, prev, pendingRetry = /* @__PURE__ */ new Map()) {
+	for (const [k, stored] of pendingRetry) if (await appendWithRetry(stored)) pendingRetry.delete(k);
+	const { obs, parentStartedAt, childStartedAt, logFiles, aliveChildStartedAt, watcherCount } = await observeChildren();
+	const { events, next } = stepRouter(prev, obs, Date.now(), { aliveChildStartedAt });
+	const enriched = await Promise.all(events.map(async (ev) => {
+		let tail = null;
+		let git_head = null;
+		if (ev.edge !== "exited") [tail, git_head] = await Promise.all([recentTail(logFiles.get(ev.child_pid)).catch(() => null), gitHead(ev.cwd).catch(() => null)]);
+		return {
+			ts: Date.now(),
+			host,
+			parent_pid: ev.parent_pid,
+			parent_started_at: ev.parent_started_at ?? parentStartedAt.get(ev.child_pid) ?? 0,
+			child_pid: ev.child_pid,
+			child_wrapper_pid: ev.child_wrapper_pid,
+			child_started_at: ev.child_started_at ?? childStartedAt.get(ev.child_pid) ?? 0,
+			cli: ev.cli,
+			cwd: ev.cwd,
+			edge: ev.edge,
+			prev_state: ev.prev_state,
+			state: ev.state,
+			question: ev.question,
+			tail,
+			git_head
+		};
+	}));
+	for (const stored of enriched) {
+		if (await appendWithRetry(stored)) continue;
+		if (pendingRetry.size < RETRY_CAP) {
+			pendingRetry.set(retryKey(stored), stored);
+			logger.warn(`[notifyd] append failed for parent ${stored.parent_pid} — queued for retry`);
+		} else logger.warn(`[notifyd] retry queue full (${RETRY_CAP}) — dropping edge for parent ${stored.parent_pid}`);
+	}
+	return {
+		next,
+		watcherCount
+	};
+}
+/** Append with a few quick retries — a transient lock/FS blip shouldn't lose an edge. */
+async function appendWithRetry(stored, attempts = 3) {
+	for (let a = 0; a < attempts; a++) try {
+		await appendEvent(stored.parent_pid, stored);
+		return true;
+	} catch {
+		await new Promise((r) => setTimeout(r, 25 * (a + 1)));
+	}
+	return false;
+}
+async function gcTick(host) {
+	const records = await listRecords(void 0, {
+		...LS_OPTS,
+		all: true
+	}).catch(() => []);
+	const livePids = /* @__PURE__ */ new Set();
+	const childParentPids = /* @__PURE__ */ new Set();
+	for (const r of records) {
+		if (isPidAlive(r.pid)) livePids.add(r.wrapper_pid ?? r.pid);
+		if (typeof r.parent_pid === "number" && r.parent_pid > 0 && isPidAlive(r.pid)) childParentPids.add(r.parent_pid);
+	}
+	await gcInboxes(host, livePids, childParentPids);
+}
+/**
+* The running daemon's full identity, or null. The lock owner file is the SINGLE
+* source of truth: trusted only if it is COMPLETE (pid + started_at + ts), its
+* pid is alive, AND its heartbeat is fresh. A recycled pid isn't refreshing this
+* file, so its stale ts (or a torn/partial owner) yields null — we never trust or
+* kill an unrelated process. `stop` re-reads and re-checks this identity right
+* before signalling, so it can't SIGTERM a pid recycled between status and stop.
+*
+* Residual edge (documented, not yet closed): a pid recycled onto an UNRELATED
+* live process WITHIN the tight OWNER_TTL window (a few ticks) could be briefly
+* trusted, since we compare our recorded `started_at` against the owner file, not
+* against the OS's actual process start time (which is non-portable to read:
+* `/proc/<pid>/stat` on Linux vs `proc_pidinfo`/`ps -o lstart` on macOS). The
+* heartbeat freshness + tight TTL keep the window to seconds; a real OS
+* start-time cross-check is deferred to a future issue.
+*/
+async function daemonIdentity(now = Date.now()) {
+	const raw = await readFile(daemonLockOwnerPath(), "utf8").catch(() => "");
+	try {
+		const o = JSON.parse(raw);
+		if (typeof o?.pid === "number" && o.pid > 0 && typeof o.started_at === "number" && o.started_at > 0 && typeof o.ts === "number" && now - o.ts <= OWNER_TTL_MS && isPidAlive(o.pid)) return {
+			pid: o.pid,
+			started_at: o.started_at,
+			ts: o.ts,
+			token: typeof o.token === "string" ? o.token : null
+		};
+	} catch {}
+	return null;
+}
+/** The running daemon's pid, or null (see daemonIdentity for the trust rules). */
+async function daemonStatus(now = Date.now()) {
+	return (await daemonIdentity(now))?.pid ?? null;
+}
+/**
+* Cooperatively request the running daemon to stop, NON-DESTRUCTIVELY: remove its
+* lock rather than SIGTERM-ing the pid. The daemon checks its owner token every
+* tick and exits when the lock is gone, so a pid recycled onto an unrelated
+* process is never signalled. Returns the daemon's pid if one was running, else
+* null. (A wedged daemon that isn't ticking relies on OS/self-exit — a residual
+* tracked in the follow-up issue.)
+*/
+async function requestDaemonStop() {
+	const id = await daemonIdentity();
+	if (!id || id.token === null) return null;
+	if (await readDaemonOwnerToken() !== id.token) return null;
+	await rm(daemonLockDir(), {
+		recursive: true,
+		force: true
+	}).catch(() => {});
+	return id.pid;
+}
+/** Ensure a daemon is running; best-effort spawn detached. Returns its pid or null. */
+async function ensureDaemon() {
+	const existing = await daemonStatus();
+	if (existing) return existing;
+	const { spawn } = await import("node:child_process");
+	const ayBin = Bun.which("ay") ?? process.argv[1];
+	if (!ayBin) return null;
+	const [cmd, ...pre] = process.platform === "win32" ? [ayBin] : [process.execPath, ayBin];
+	const child = spawn(cmd, [
+		...pre,
+		"notifyd",
+		"run"
+	], {
+		detached: true,
+		stdio: "ignore"
+	});
+	child.on("error", () => {});
+	child.unref();
+	const PHI = 1.618;
+	let delay = 50;
+	let waited = 0;
+	const BUDGET_MS = 3e3;
+	for (;;) {
+		await new Promise((r) => setTimeout(r, delay));
+		waited += delay;
+		const pid = await daemonStatus();
+		if (pid) return pid;
+		if (waited >= BUDGET_MS) return null;
+		delay = Math.min(Math.round(delay * PHI), 800);
+	}
+}
+
+//#endregion
+export { daemonStatus, ensureDaemon, requestDaemonStop, runDaemon };
+//# sourceMappingURL=notifyDaemon-BlGV0y4j.js.map

package/dist/{openBrowser-CCF1iuQK.js → openBrowser-ChR4llYa.js}

@@ -68,4 +68,4 @@ async function offerOpenInBrowser(url, prompt = "Open in browser now? [Y/n] ") {
 
 //#endregion
 export { offerOpenInBrowser };
-//# sourceMappingURL=openBrowser-CCF1iuQK.js.map
+//# sourceMappingURL=openBrowser-ChR4llYa.js.map

package/dist/{pidStore-BfoBWUjc.js → pidStore-BIvsBQ8X.js}

@@ -1,6 +1,6 @@
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
-import { a as updateGlobalPidStatus, n as maybeCompactGlobalPids, r as pruneOldLogs, t as appendGlobalPid } from "./globalPidIndex-DlmmJlO8.js";
+import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
+import { a as updateGlobalPidStatus, n as maybeCompactGlobalPids, r as pruneOldLogs, t as appendGlobalPid } from "./globalPidIndex-CoNr7tS8.js";
 import { closeSync, existsSync, fsyncSync, openSync } from "fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
 import path from "path";
@@ -368,4 +368,4 @@ pid-db/
 
 //#endregion
 export { PidStore as t };
-//# sourceMappingURL=pidStore-BfoBWUjc.js.map
+//# sourceMappingURL=pidStore-BIvsBQ8X.js.map

package/dist/pidStore-CLxwp0qI.js

@@ -0,0 +1,5 @@
+import "./logger-CDIsZ-Pp.js";
+import { t as PidStore } from "./pidStore-BIvsBQ8X.js";
+import "./globalPidIndex-CoNr7tS8.js";
+
+export { PidStore };

package/dist/{reaper-C-eWAxIj.js → reaper-CWF2_ATd.js}

@@ -1,5 +1,5 @@
-import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
-import { appendFile, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
+import { appendFile, mkdir, readFile, readdir, rename, unlink, writeFile } from "fs/promises";
 import path from "path";
 
 //#region ts/reaper.ts
@@ -49,6 +49,7 @@ async function register(wrapperPid, pgid) {
 /** SIGKILL the recorded group of every agent whose wrapper has exited, and
 *  rewrite the registry keeping only still-running agents. Best-effort. */
 async function sweep() {
+	await pruneStaleActivityMarkers();
 	let content;
 	try {
 		content = await readFile(registryPath(), "utf8");
@@ -80,7 +81,30 @@ async function sweep() {
 		await rename(tmp, registryPath());
 	} catch {}
 }
+/** Prune typing-activity markers (`activity/<pid>.stdin`) left by hard-killed
+*  agents whose own exit cleanup never ran. Independent of the reaper registry
+*  above, so it catches every dead pid. A leaked marker is harmless (it ages out
+*  of the typing window and stopped agents never render the chip); this just
+*  keeps the dir from accumulating dead entries. Mirrors rs/src/fifo.rs
+*  `prune_stale_activity_markers`. Best-effort. */
+async function pruneStaleActivityMarkers() {
+	const dir = path.join(agentYesHome(), "activity");
+	let names;
+	try {
+		names = await readdir(dir);
+	} catch {
+		return;
+	}
+	await Promise.all(names.map(async (name) => {
+		if (!name.endsWith(".stdin")) return;
+		const pid = Number(name.slice(0, -6));
+		if (!Number.isInteger(pid) || isAlive(pid)) return;
+		try {
+			await unlink(path.join(dir, name));
+		} catch {}
+	}));
+}
 
 //#endregion
 export { register as n, sweep as r, pgidForWrapper as t };
-//# sourceMappingURL=reaper-C-eWAxIj.js.map
+//# sourceMappingURL=reaper-CWF2_ATd.js.map

package/dist/{reaper-BQgDb85W.js → reaper-jfSmog15.js}

@@ -1,3 +1,3 @@
-import { n as register, r as sweep, t as pgidForWrapper } from "./reaper-C-eWAxIj.js";
+import { n as register, r as sweep, t as pgidForWrapper } from "./reaper-CWF2_ATd.js";
 
 export { sweep };

package/dist/{remotes-cx_GDFPj.js → remotes-BQMr4_En.js}

@@ -1,5 +1,5 @@
-import "./e2e-BeKjLhmO.js";
-import "./webrtcLink-BG0Xc4-W.js";
-import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-BmAPylU_.js";
+import "./e2e-jb0Hp43q.js";
+import "./webrtcLink-B7REGtK2.js";
+import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-CC-4GuJb.js";
 
 export { cmdRemote };