agent-yes 1.265.4 → 1.266.0

package/dist/notifyStore-Cbw2ZJ0X.js

@@ -0,0 +1,559 @@
+import { n as logger } from "./logger-CDIsZ-Pp.js";
+import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
+import { appendFile, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
+import path from "path";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+
+//#region ts/notifyInbox.ts
+/**
+* Pure, fs-free core for the subagent→parent notification inbox — the storage
+* and watermark layer under `ay notify` / `ay notifyd`.
+*
+* Motivation (real incident): a parent agent fanned out sub-agents that finished
+* their work but sat at an idle `❯` prompt WITHOUT exiting (claude-yes does not
+* exit on idle). Claude Code's background-task notification only fires on process
+* EXIT, so the parent never learned the children went idle and left them parked
+* 16 minutes. `ay ls --watch` already streams transitions, but it is PULL: the
+* parent must run the watch loop. The whole point of this pain is the parent is
+* NOT watching. So we accumulate qualifying edges into a per-parent append-only
+* inbox that the parent drains on its own schedule (its Monitor loop), with a
+* persisted cursor so a parent that restarts reads only the unread edges.
+*
+* This module is the pure part (path math, NDJSON (de)serialization, seq/cursor
+* filtering, retention decisions) so it is trivially unit-testable, mirroring
+* `lsWatch.ts` / `needsInput.ts` / `resultEnvelope.ts`. The fs read/write + lock
+* + CLI live in `subcommands.ts`; the detection/debounce lives in
+* `notifyRouter.ts`.
+*/
+/** Root dir for all notification state. */
+function notifyDir() {
+	return path.join(agentYesHome(), "notify");
+}
+/** Per-host inbox directory (pids are only unique within a host). */
+function inboxDir(host) {
+	return path.join(notifyDir(), "inbox", sanitizeHost(host));
+}
+/** Absolute path of one parent's append-only NDJSON inbox. */
+function inboxPath(host, parentPid) {
+	return path.join(inboxDir(host), `${parentPid}.ndjson`);
+}
+/** Sidecar seq counter for a parent inbox (last allocated seq). */
+function seqPath(host, parentPid) {
+	return path.join(inboxDir(host), `${parentPid}.seq`);
+}
+/** Per-consumer cursor directory for a parent inbox. */
+function cursorDir(host, parentPid) {
+	return path.join(notifyDir(), "cursors", sanitizeHost(host), String(parentPid));
+}
+/** Absolute path of one consumer's cursor file for a parent inbox. */
+function cursorPath(host, parentPid, consumer = "parent") {
+	return path.join(cursorDir(host, parentPid), `${sanitizeConsumer(consumer)}.json`);
+}
+/** The daemon singleton lock dir (mkdir-based, like pidStore). */
+function daemonLockDir() {
+	return path.join(notifyDir(), "notifyd.lock");
+}
+/**
+* Owner metadata inside the lock dir ({pid, started_at, ts}) — the SINGLE source
+* of truth for the running daemon's identity, used for stale-lock steal and for
+* `notifyd status`/`stop` (a running daemon refreshes `ts` each tick).
+*/
+function daemonLockOwnerPath() {
+	return path.join(daemonLockDir(), "owner.json");
+}
+/** Registry dir of parents currently running `ay notify watch` (heartbeats). */
+function watchersDir() {
+	return path.join(notifyDir(), "watchers");
+}
+/** Heartbeat file for one watching parent. */
+function watcherPath(parentPid) {
+	return path.join(watchersDir(), `${parentPid}.json`);
+}
+/** A watcher heartbeat is "live" if refreshed within this window. */
+const WATCHER_TTL_MS = 15e3;
+function sanitizeSegment(s, fallback) {
+	const cleaned = s.replace(/[^A-Za-z0-9._-]/g, "_");
+	return cleaned === "" || cleaned === "." || cleaned === ".." ? fallback : cleaned;
+}
+function sanitizeHost(host) {
+	return sanitizeSegment(host, "localhost");
+}
+function sanitizeConsumer(consumer) {
+	return sanitizeSegment(consumer, "parent");
+}
+/** Serialize one event to its NDJSON line (no trailing newline). */
+function serializeEvent(ev) {
+	return JSON.stringify(ev);
+}
+/**
+* Parse an inbox's raw text into events. Tolerant by design: a torn final line
+* (a writer mid-append) or any unparseable line is skipped, never throws — a
+* reader must survive a concurrent writer. Order is file order (= seq order,
+* since a single locked writer appends in increasing seq).
+*/
+function parseInboxText(text) {
+	const out = [];
+	for (const line of text.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		try {
+			const ev = JSON.parse(t);
+			if (isValidEvent(ev)) out.push(ev);
+		} catch {}
+	}
+	return out;
+}
+const EDGES = new Set([
+	"needs_input",
+	"idle",
+	"exited"
+]);
+/**
+* Full shape validation at the storage boundary — a torn/partial line missing
+* the correlation fields must never flow through to a consumer's output. Every
+* event we surface has the fields a reader relies on.
+*/
+function isValidEvent(ev) {
+	if (!ev || typeof ev !== "object") return false;
+	const e = ev;
+	return typeof e.seq === "number" && typeof e.ts === "number" && typeof e.host === "string" && typeof e.parent_pid === "number" && typeof e.child_pid === "number" && typeof e.cli === "string" && typeof e.cwd === "string" && typeof e.edge === "string" && EDGES.has(e.edge) && typeof e.state === "string" && (e.question === null || typeof e.question === "string");
+}
+/** Next seq to allocate given the last stored seq counter (or the inbox max). */
+function nextSeq(lastSeq) {
+	return (Number.isFinite(lastSeq) && lastSeq > 0 ? lastSeq : 0) + 1;
+}
+/** Highest seq present in a parsed inbox (0 when empty). */
+function maxSeq(events) {
+	let m = 0;
+	for (const e of events) if (e.seq > m) m = e.seq;
+	return m;
+}
+/**
+* Filter events for `--since <seq>`: strictly-greater than the given seq. A
+* `since` of 0/undefined returns everything.
+*/
+function filterSinceSeq(events, sinceSeq) {
+	if (!sinceSeq || sinceSeq <= 0) return events.slice();
+	return events.filter((e) => e.seq > sinceSeq);
+}
+/** Filter events after a wall-clock `--since <ts>` (inclusive lower bound). */
+function filterSinceTs(events, sinceTs) {
+	if (!sinceTs || sinceTs <= 0) return events.slice();
+	return events.filter((e) => e.ts >= sinceTs);
+}
+/** Unread = seq strictly greater than the consumer's cursor. */
+function filterUnread(events, cursorSeq) {
+	return events.filter((e) => e.seq > (cursorSeq > 0 ? cursorSeq : 0));
+}
+/** Parse a cursor file's text; a missing/garbage cursor reads as seq 0. */
+function parseCursor(text) {
+	if (!text) return { seq: 0 };
+	try {
+		const c = JSON.parse(text);
+		return { seq: Number.isFinite(c?.seq) && c.seq > 0 ? c.seq : 0 };
+	} catch {
+		return { seq: 0 };
+	}
+}
+function serializeCursor(seq) {
+	return JSON.stringify({ seq: Math.max(0, Math.floor(seq)) });
+}
+/**
+* Which incarnation of a parent pid a POSTMORTEM read should show (pure).
+*
+* The normal read path resolves the parent's `started_at` from the registry and
+* fails closed when there is no live record — deliberately, so a recycled pid
+* can't read a prior session's inbox. That also makes a FINISHED parent's inbox
+* permanently uninspectable, which is exactly when an operator wants to see what
+* the children reported. Postmortem keeps the identity guard but takes the
+* identity from the inbox's own `parent_started_at` stamps instead.
+*
+* - An explicit choice always wins.
+* - One distinct stamp is unambiguous — use it.
+* - Several mean the pid was reused across sessions and the file holds more than
+*   one agent's edges: refuse and list them rather than guess, because guessing
+*   would show one agent's children under another's name.
+* - None (a legacy, identity-less inbox) yields 0 = "no filter"; there is nothing
+*   to disambiguate and nothing to mis-attribute.
+*
+* Issue #169 item 6.
+*/
+function postmortemStartedAt(events, explicit) {
+	if (Number.isFinite(explicit) && explicit > 0) return explicit;
+	const distinct = [...new Set(events.map((e) => e.parent_started_at ?? 0).filter((v) => v > 0))].sort((a, b) => a - b);
+	if (distinct.length === 0) return 0;
+	if (distinct.length === 1) return distinct[0];
+	throw new Error(`inbox holds edges from ${distinct.length} incarnations of this pid (started_at ${distinct.join(", ")}) — pass --started-at <ms> to pick one.`);
+}
+/** Byte size one event occupies in the inbox file (its line + newline). */
+function eventBytes(events) {
+	let n = 0;
+	for (const e of events) n += serializeEvent(e).length + 1;
+	return n;
+}
+/**
+* EMERGENCY rotation (pure): keep the newest events that fit `capBytes`,
+* IGNORING the un-acked watermark that {@link rotateKeep} protects.
+*
+* This is the escape hatch for the one way an inbox can grow without bound: a
+* parent that watches WITHOUT `--ack` (the default, at-least-once) never
+* advances its cursor, so every event stays protected and normal rotation can
+* trim nothing. That is the right default — an unacked edge must not be dropped
+* — but "right" stops being right once the file threatens the disk. Past a hard
+* cap well above the soft one, dropping the OLDEST unacked events (loudly) beats
+* unbounded growth.
+*
+* `minKeep` still floors the result, so the newest edges — the ones a parent is
+* most likely to still act on — are never the ones sacrificed.
+*
+* Issue #169 item 3.
+*/
+function emergencyKeep(events, capBytes, minKeep = 100) {
+	if (events.length <= minKeep) return events.slice();
+	const kept = [];
+	let bytes = 0;
+	for (let i = events.length - 1; i >= 0; i--) {
+		const e = events[i];
+		bytes += serializeEvent(e).length + 1;
+		if (kept.length < minKeep || bytes <= capBytes) kept.push(e);
+		else break;
+	}
+	kept.reverse();
+	return kept;
+}
+/**
+* Rotation decision (pure): given an inbox's events, a byte cap, and the minimum
+* un-acked cursor across ALL consumers, return the events to KEEP after
+* rotating. Critically, an event with `seq > protectAboveSeq` is NEVER dropped —
+* that is the at-least-once guarantee: we must not evict an edge no consumer has
+* acknowledged yet, even under the byte cap. Below that watermark we keep the
+* newest events that fit the cap (and at least `minKeep`).
+*/
+function rotateKeep(events, capBytes, protectAboveSeq = 0, minKeep = 100) {
+	if (events.length <= minKeep) return events.slice();
+	const kept = [];
+	let bytes = 0;
+	for (let i = events.length - 1; i >= 0; i--) {
+		const e = events[i];
+		const line = serializeEvent(e) + "\n";
+		bytes += line.length;
+		if (e.seq > protectAboveSeq || kept.length < minKeep || bytes <= capBytes) kept.push(e);
+		else break;
+	}
+	kept.reverse();
+	return kept;
+}
+
+//#endregion
+//#region ts/notifyStore.ts
+/**
+* Filesystem side of the notification inbox — the impure half of the pure
+* `notifyInbox.ts` path/serialization core. Handles the locked append (so
+* concurrent daemon ticks / future writers never interleave a seq), inbox and
+* cursor reads/writes, and retention GC.
+*
+* The lock is a mkdir-based advisory lock (same primitive `pidStore` uses), held
+* only for the microseconds of a read-counter → append-line → write-counter, so
+* contention is negligible even with many parents.
+*/
+/** Stable local host id — the pid namespace is per-host. */
+function hostId() {
+	return os.hostname() || "localhost";
+}
+function pidAlive(pid) {
+	if (!Number.isFinite(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (e) {
+		return e.code === "EPERM";
+	}
+}
+/**
+* Pure steal decision for a per-inbox lock (extracted so it's unit-testable):
+* steal the lock ONLY when its holder is provably gone (torn/missing owner on a
+* lock that has EXISTED longer than the grace, or a dead pid) or its heartbeat is
+* stale — NEVER merely because the contender has waited a while.
+*
+* Crucially, the torn-owner grace is measured from the LOCK INSTANCE's age
+* (`lockAgeMs` = now − lockDir mtime), NOT from how long the contender has been
+* waiting. Otherwise a contender that waited out one holder could instantly steal
+* the NEXT holder's freshly-created lock during its mkdir→write-owner window
+* (torn but brand-new) — letting two writers into the critical section.
+*/
+function shouldStealLock(ownerRaw, now, opts) {
+	const graceMs = opts.graceMs ?? 1e3;
+	let ownerPid = 0;
+	let ownerTs = 0;
+	let parsed = false;
+	try {
+		const o = JSON.parse(ownerRaw);
+		ownerPid = o?.pid ?? 0;
+		ownerTs = o?.ts ?? 0;
+		parsed = true;
+	} catch {}
+	if (!parsed || ownerPid <= 0 || ownerTs <= 0) return opts.lockAgeMs > graceMs;
+	const holderDead = ownerPid !== opts.selfPid && !opts.isAlive(ownerPid);
+	const holderStale = now - ownerTs > opts.staleMs;
+	return holderDead || holderStale;
+}
+async function ensureDir(dir) {
+	await mkdir(dir, { recursive: true }).catch(() => {});
+}
+/**
+* Atomically overwrite a single file (temp + rename) so a concurrent reader never
+* observes a torn/partial write — the sweep invariant for every single-file
+* mutation (cursor, watcher heartbeat, lock owner). Returns whether it landed.
+*/
+async function atomicWrite(file, data) {
+	const tmp = `${file}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(tmp, data);
+		await rename(tmp, file);
+		return true;
+	} catch {
+		await rm(tmp, { force: true }).catch(() => {});
+		return false;
+	}
+}
+/**
+* Acquire a per-inbox lock; returns a release fn. Ownership is proven ONLY by a
+* successful `mkdir(recursive:false)` (atomic exclusive create), and stealing is
+* driven by HOLDER LIVENESS, not elapsed wait time: the holder writes an
+* `owner` file ({pid, ts}) on acquire AND heartbeats its ts for the whole time
+* it holds the lock, so a contender steals ONLY when that holder is dead or its
+* heartbeat is stale. A live holder whose critical section legitimately runs long
+* (a big GC rewrite, a slow disk) is never robbed — its heartbeat stays fresh;
+* and a wedged holder stops heartbeating, so staleMs still reclaims it. There is
+* deliberately NO wall-clock backstop: elapsed wait time alone never steals, so a
+* live holder is inviolable.
+*/
+function isTransientLockMkdirError(code, platform = process.platform) {
+	if (code === "EEXIST") return true;
+	return platform === "win32" && (code === "EPERM" || code === "EBUSY" || code === "ENOTEMPTY" || code === "EACCES");
+}
+async function acquireLock(lockDir, staleMs = 3e4) {
+	const ownerFile = path.join(lockDir, "owner");
+	const token = randomUUID();
+	const readOwnerToken = async () => {
+		try {
+			return JSON.parse(await readFile(ownerFile, "utf8")).token ?? null;
+		} catch {
+			return null;
+		}
+	};
+	const stampOwner = async () => {
+		const tmp = `${ownerFile}.${token}.tmp`;
+		try {
+			await writeFile(tmp, JSON.stringify({
+				pid: process.pid,
+				ts: Date.now(),
+				token
+			}));
+			await rename(tmp, ownerFile);
+			return true;
+		} catch {
+			await rm(tmp, { force: true }).catch(() => {});
+			return false;
+		}
+	};
+	const lockAgeMs = async () => {
+		const m = await stat(lockDir).then((s) => s.mtimeMs).catch(() => Date.now());
+		return Date.now() - m;
+	};
+	let transientErrors = 0;
+	for (;;) try {
+		await mkdir(lockDir, { recursive: false });
+		if (!await stampOwner()) {
+			await rm(lockDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			await new Promise((r) => setTimeout(r, 15));
+			continue;
+		}
+		const beat = setInterval(() => {
+			(async () => {
+				if (await readOwnerToken() !== token) {
+					clearInterval(beat);
+					return;
+				}
+				await stampOwner();
+			})();
+		}, Math.max(500, Math.floor(staleMs / 3)));
+		if (typeof beat.unref === "function") beat.unref();
+		return async () => {
+			clearInterval(beat);
+			if (await readOwnerToken() === token) await rm(lockDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+		};
+	} catch (e) {
+		const code = e.code;
+		if (!isTransientLockMkdirError(code)) throw e;
+		if (code !== "EEXIST") {
+			if (++transientErrors > 200) throw e;
+			await new Promise((r) => setTimeout(r, 15));
+			continue;
+		}
+		if (shouldStealLock(await readFile(ownerFile, "utf8").catch(() => ""), Date.now(), {
+			staleMs,
+			lockAgeMs: await lockAgeMs(),
+			selfPid: process.pid,
+			isAlive: pidAlive
+		})) {
+			await rm(lockDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			continue;
+		}
+		await new Promise((r) => setTimeout(r, 15));
+	}
+}
+/**
+* Append one event to a parent's inbox under lock, allocating the next seq. The
+* caller passes the event WITHOUT seq (we stamp it). Returns the stamped seq.
+*/
+async function appendEvent(parentPid, ev) {
+	const host = ev.host;
+	const dir = inboxDir(host);
+	await ensureDir(dir);
+	const release = await acquireLock(path.join(dir, `${parentPid}.lock`));
+	try {
+		let last = 0;
+		const counterRaw = await readFile(seqPath(host, parentPid), "utf8").catch(() => "");
+		const parsed = parseInt(counterRaw.trim(), 10);
+		if (Number.isFinite(parsed) && parsed > 0) last = parsed;
+		else last = maxSeq(parseInboxText(await readFile(inboxPath(host, parentPid), "utf8").catch(() => "")));
+		const seq = nextSeq(last);
+		const full = {
+			...ev,
+			seq
+		};
+		await writeFile(seqPath(host, parentPid), String(seq));
+		await appendFile(inboxPath(host, parentPid), serializeEvent(full) + "\n");
+		return seq;
+	} finally {
+		await release();
+	}
+}
+/** Read + parse a parent's inbox (empty array when none). */
+async function readInbox(host, parentPid) {
+	return parseInboxText(await readFile(inboxPath(host, parentPid), "utf8").catch(() => ""));
+}
+/** All parent pids that currently have an inbox on this host. */
+async function listInboxParents(host) {
+	const names = await readdir(inboxDir(host)).catch(() => []);
+	const pids = [];
+	for (const n of names) {
+		const m = /^(\d+)\.ndjson$/.exec(n);
+		if (m) pids.push(parseInt(m[1], 10));
+	}
+	return pids;
+}
+async function getCursor(host, parentPid, consumer = "parent") {
+	return parseCursor(await readFile(cursorPath(host, parentPid, consumer), "utf8").catch(() => null)).seq;
+}
+/**
+* Minimum cursor across ALL consumers of a parent inbox — the watermark below
+* which rotation may evict events (nothing above it has been acked by every
+* reader). Returns 0 when there are no consumers — which PROTECTS EVERYTHING:
+* with a 0 watermark, `rotateKeep` treats every event as unacked and evicts
+* nothing (an inbox nobody reads is never trimmed).
+*/
+async function minConsumerCursor(host, parentPid) {
+	const cursors = (await readdir(cursorDir(host, parentPid)).catch(() => [])).filter((n) => n.endsWith(".json")).map((n) => n.slice(0, -5));
+	if (cursors.length === 0) return 0;
+	let min = Infinity;
+	for (const c of cursors) min = Math.min(min, await getCursor(host, parentPid, c));
+	return Number.isFinite(min) ? min : 0;
+}
+async function setCursor(host, parentPid, seq, consumer = "parent") {
+	const p = cursorPath(host, parentPid, consumer);
+	await ensureDir(path.dirname(p));
+	await atomicWrite(p, serializeCursor(seq));
+}
+/**
+* Retention: delete inboxes (+ their seq counter + cursors) for parents that are
+* both dead and unreferenced by any live child. `capBytes` also rotates a live
+* inbox that has grown past the cap, keeping the newest events.
+*/
+async function gcInboxes(host, livePids, liveChildParentPids, capBytes = 10 * 1024 * 1024, hardCapBytes = capBytes * 4) {
+	const parents = await listInboxParents(host);
+	for (const p of parents) {
+		const release = await acquireLock(path.join(inboxDir(host), `${p}.lock`));
+		try {
+			if (!livePids.has(p) && !liveChildParentPids.has(p)) {
+				await rm(inboxPath(host, p), { force: true }).catch(() => {});
+				await rm(seqPath(host, p), { force: true }).catch(() => {});
+				await rm(cursorDir(host, p), {
+					recursive: true,
+					force: true
+				}).catch(() => {});
+				continue;
+			}
+			const size = await stat(inboxPath(host, p)).then((s) => s.size).catch(() => 0);
+			if (size <= capBytes) continue;
+			const events = await readInbox(host, p);
+			let kept = rotateKeep(events, capBytes, await minConsumerCursor(host, p));
+			let dropped = [];
+			if (eventBytes(kept) > hardCapBytes) {
+				const before = kept;
+				kept = emergencyKeep(kept, capBytes);
+				dropped = before.slice(0, before.length - kept.length);
+			}
+			if (kept.length < events.length) {
+				await writeFile(inboxPath(host, p), kept.map(serializeEvent).join("\n") + "\n");
+				if (dropped.length > 0) logger.error(`[notify] EMERGENCY TRIM: inbox for parent ${p} exceeded the hard cap ${hardCapBytes} bytes — dropped ${dropped.length} UNACKED events (seq ${dropped[0].seq}..${dropped[dropped.length - 1].seq}). The consumer's cursor is not advancing: run \`ay notify watch --ack\` (or \`ay notify cursor set <seq>\`) for parent ${p}.`);
+			} else logger.warn(`[notify] inbox for parent ${p} is ${size} bytes (> soft cap ${capBytes}) but all events are unacked — cursor not advancing?`);
+		} finally {
+			await release();
+		}
+	}
+}
+/** Register / refresh this parent's watch heartbeat (atomically, so a concurrent
+* liveWatchers never reads a torn file and transiently drops the watcher). */
+async function heartbeatWatcher(parentPid, startedAt) {
+	await ensureDir(watchersDir());
+	await atomicWrite(watcherPath(parentPid), JSON.stringify({
+		pid: parentPid,
+		started_at: startedAt,
+		ts: Date.now(),
+		watch_pid: process.pid
+	}));
+}
+/** Remove this parent's watch heartbeat (on watch exit). */
+async function clearWatcher(parentPid) {
+	await rm(watcherPath(parentPid), { force: true }).catch(() => {});
+}
+/**
+* Live watchers as a map of parent pid → the parent's own `started_at` (its
+* authoritative self-reported start time, so the daemon never has to guess it
+* from the registry and stamp a 0). A watcher counts as live ONLY if its
+* heartbeat is fresh AND its process is actually alive — so a crashed `watch`
+* whose heartbeat lingers for the TTL doesn't keep the daemon writing to a dead
+* parent's inbox (which would violate "nothing happens unless you watch"). A
+* heartbeat with a missing/non-positive `started_at` is treated as NOT live: the
+* daemon's cross-session scope guard keys off a positive parent start time, so a
+* 0 would defeat it — fail closed.
+*/
+async function liveWatchers(now = Date.now()) {
+	const names = await readdir(watchersDir()).catch(() => []);
+	const live = /* @__PURE__ */ new Map();
+	for (const n of names) {
+		if (!n.endsWith(".json")) continue;
+		const raw = await readFile(path.join(watchersDir(), n), "utf8").catch(() => "");
+		try {
+			const o = JSON.parse(raw);
+			if (typeof o?.pid === "number" && typeof o?.started_at === "number" && o.started_at > 0 && typeof o?.ts === "number" && now - o.ts <= WATCHER_TTL_MS && pidAlive(o.pid) && (typeof o.watch_pid !== "number" || o.watch_pid <= 0 || pidAlive(o.watch_pid))) live.set(o.pid, o.started_at);
+		} catch {}
+	}
+	return live;
+}
+
+//#endregion
+export { postmortemStartedAt as S, filterSinceSeq as _, getCursor as a, maxSeq as b, isTransientLockMkdirError as c, minConsumerCursor as d, readInbox as f, daemonLockOwnerPath as g, daemonLockDir as h, gcInboxes as i, listInboxParents as l, shouldStealLock as m, appendEvent as n, heartbeatWatcher as o, setCursor as p, clearWatcher as r, hostId as s, acquireLock as t, liveWatchers as u, filterSinceTs as v, notifyDir as x, filterUnread as y };
+//# sourceMappingURL=notifyStore-Cbw2ZJ0X.js.map

package/dist/{openBrowser-Cw8hg7ok.js → openBrowser-DhQ9pJRi.js}

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

package/dist/parentLink-B798ASCW.js

@@ -0,0 +1,5 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import { n as spawnerFromRecords, t as resolveSpawner } from "./parentLink-C0cIRjfL.js";
+
+export { resolveSpawner };

package/dist/parentLink-C0cIRjfL.js

@@ -0,0 +1,53 @@
+import { i as readGlobalPids } from "./globalPidIndex-Dq4KY2IV.js";
+
+//#region ts/parentLink.ts
+/**
+* Resolve "who spawned me" from the wrapper-pid link the registry already
+* carries, into an addressable identity.
+*
+* The link itself is just a number: a nested `ay` inherits its parent wrapper's
+* `AGENT_YES_PID` and records it as `parent_pid` (see globalPidIndex's
+* GlobalPidRecord). To actually TALK to that parent — which is what
+* `<ay-init-msg>` and the finished/stuck ping both need — we have to map that
+* wrapper pid back to the parent's canonical record, because the reply route is
+* its `agent_id` (stable across restart), not its pid.
+*
+* Shared by ts/initMsg.ts's caller and ts/parentPing's delivery so both address
+* the SAME identity — a child that reports to a different route than the one
+* printed in its own init block would be maddening to debug.
+*/
+/**
+* The parent agent for `parentPid` (a parent WRAPPER pid), or null.
+*
+* Null covers three different situations that all mean the same thing here —
+* "nobody to report to": no parent at all (top-level, human-launched); a parent
+* whose record aged out of the registry; or a parent on another host. Callers
+* treat all three as "skip the wrapper / skip the ping" rather than guessing a
+* route that would silently go nowhere.
+*/
+async function resolveSpawner(parentPid) {
+	if (typeof parentPid !== "number" || !Number.isInteger(parentPid) || parentPid <= 0) return null;
+	let records;
+	try {
+		records = await readGlobalPids();
+	} catch {
+		return null;
+	}
+	return spawnerFromRecords(records, parentPid);
+}
+/** Pure half of resolveSpawner, so the match rule is testable without the fs. */
+function spawnerFromRecords(records, parentPid) {
+	const matches = records.filter((r) => r.wrapper_pid === parentPid);
+	const parent = matches.find((r) => r.status !== "exited") ?? matches[0];
+	if (!parent) return null;
+	return {
+		cli: parent.cli,
+		pid: parent.pid,
+		agentId: parent.agent_id ?? null,
+		cwd: parent.cwd
+	};
+}
+
+//#endregion
+export { spawnerFromRecords as n, resolveSpawner as t };
+//# sourceMappingURL=parentLink-C0cIRjfL.js.map