agent-yes 1.265.4 → 1.266.0

package/dist/{subcommands-CQPnT5qu.js → subcommands-DtF31RoW.js}

@@ -1,23 +1,23 @@
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
-import { n as logger } from "./logger-CDIsZ-Pp.js";
 import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-Dq4KY2IV.js";
 import { a as recordOutbox, i as recordMessage, n as readMailbox, t as partyMatches } from "./messageLog-BYFwioFY.js";
 import { t as loadSharedCliDefaults } from "./configShared-DtHMBCl7.js";
-import { n as isWebrtcSpec } from "./webrtcLink-CS4D-3G1.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-iIvqiFWK.js";
+import { n as isWorkingScreen, r as parseMenu, t as classifyNeedsInput } from "./needsInput-103zhZ90.js";
+import { S as postmortemStartedAt, _ as filterSinceSeq, a as getCursor, b as maxSeq, f as readInbox, o as heartbeatWatcher, p as setCursor, r as clearWatcher, s as hostId, v as filterSinceTs, y as filterUnread } from "./notifyStore-Cbw2ZJ0X.js";
+import { n as isWebrtcSpec } from "./webrtcLink-DyCj380i.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-iMhdZytp.js";
 import { spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
-import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
+import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
-import { randomUUID } from "node:crypto";
 import { readFileSync } from "node:fs";
 import path$1 from "node:path";
-import os$1, { homedir as homedir$1, hostname as hostname$1, userInfo as userInfo$1 } from "node:os";
+import { homedir as homedir$1, hostname as hostname$1, userInfo as userInfo$1 } from "node:os";
 import { fileURLToPath } from "node:url";
-import { randomBytes as randomBytes$1 } from "crypto";
+import { randomBytes } from "crypto";
 
 //#region ts/identity.ts
 /**
@@ -357,83 +357,6 @@ function badgeLabel(id, defs = BADGE_DEFS) {
 	return def.label.includes("$1") ? def.label.replace("$1", arg) : def.label;
 }
 
-//#endregion
-//#region ts/needsInput.ts
-function reTest(re, s) {
-	return (re.global || re.sticky ? new RegExp(re.source, re.flags.replace(/[gy]/g, "")) : re).test(s);
-}
-function isChromeLine(s) {
-	const t = s.trim();
-	return !t || /^─+$/.test(t) || /^esc to (interrupt|cancel)/i.test(t) || /\? for shortcuts/.test(t) || /\d+%\s*until auto-compact/i.test(t);
-}
-/**
-* Returns a NeedsInput when the screen shows an unresolved selection menu, else
-* null. `cfg.working` short-circuits to null (an actively-working agent isn't
-* blocked). Pure + synchronous so it's trivially unit-testable.
-*/
-function classifyNeedsInput(lines, cfg) {
-	const patterns = cfg.needsInput ?? [];
-	if (patterns.length === 0) return null;
-	const text = lines.join("\n");
-	if ((cfg.working ?? []).some((re) => reTest(re, text))) return null;
-	if (!patterns.some((re) => reTest(re, text))) return null;
-	let last = -1;
-	for (let i = 0; i < lines.length; i++) if (patterns.some((re) => reTest(re, lines[i]))) last = i;
-	const start = Math.max(0, last - 6);
-	const end = Math.min(lines.length, last + 6);
-	return { question: lines.slice(start, end).map((l) => l.trim()).filter((l) => l && !isChromeLine(l)).join(" • ").slice(0, 400) };
-}
-const OPTION_LINE = /^[\s❯›>▶◉○●·│*-]*?(\d+)\.\s/;
-/**
-* Parse the selection menu a `needs_input` agent is parked on into a cursor
-* position + the available option numbers, so a caller can compute how far the
-* cursor must move (Down/Up) to reach a target option. Returns null when the
-* screen isn't a menu (delegates that judgement to {@link classifyNeedsInput},
-* so `working` still wins) or no numbered cursor line is found. Pure — the
-* `ay select` action reuses the exact detection `ay ls` renders with.
-*/
-function parseMenu(lines, cfg) {
-	const ni = classifyNeedsInput(lines, cfg);
-	if (!ni) return null;
-	const patterns = cfg.needsInput ?? [];
-	let cursorLine = -1;
-	for (let i = 0; i < lines.length; i++) if (patterns.some((re) => reTest(re, lines[i]))) cursorLine = i;
-	if (cursorLine < 0) return null;
-	const cm = /(\d+)\./.exec(lines[cursorLine]);
-	if (!cm) return null;
-	const cursor = parseInt(cm[1], 10);
-	const start = Math.max(0, cursorLine - 12);
-	const end = Math.min(lines.length, cursorLine + 12);
-	const options = [];
-	for (let i = start; i < end; i++) {
-		const m = OPTION_LINE.exec(lines[i]);
-		if (m) {
-			const v = parseInt(m[1], 10);
-			if (!options.includes(v)) options.push(v);
-		}
-	}
-	if (!options.includes(cursor)) options.push(cursor);
-	options.sort((a, b) => a - b);
-	return {
-		cursor,
-		options,
-		question: ni.question
-	};
-}
-/**
-* True when the rendered screen still shows a "busy" marker (config `working`,
-* e.g. claude's `esc to interrupt`). Paired with a long-quiet log this is the
-* `stuck` signal: a live spinner writes to the log every frame, so a busy marker
-* on screen WITHOUT recent output means the agent wedged mid-stream (a silent
-* API stream stall) rather than finishing. Pure + synchronous like the rest of
-* this module so it's trivially unit-testable.
-*/
-function isWorkingScreen(lines, working) {
-	if (!working?.length) return false;
-	const text = lines.join("\n");
-	return working.some((re) => reTest(re, text));
-}
-
 //#endregion
 //#region ts/lsWatch.ts
 /**
@@ -490,556 +413,6 @@ function toEvent(a, ts) {
 	};
 }
 
-//#endregion
-//#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$1.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
 //#region ts/resultEnvelope.ts
 /**
@@ -1531,7 +904,7 @@ async function runSubcommand(argv) {
 			case "tail": return await cmdRead(rest, { mode: "tail" });
 			case "head": return await cmdRead(rest, { mode: "head" });
 			case "hist":
-			case "history": return await (await import("./hist-CoXBBjJt.js")).cmdHist(rest);
+			case "history": return await (await import("./hist-BpocAe1N.js")).cmdHist(rest);
 			case "send": return await cmdSend(rest);
 			case "msgs": return await cmdMsgs(rest);
 			case "key": return await cmdKey(rest);
@@ -1543,56 +916,56 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "todo": {
-				const { runTodoSubcommand } = await import("./todoCli-DZmOmcvd.js");
+				const { runTodoSubcommand } = await import("./todoCli-c_R7D7Y-.js");
 				return runTodoSubcommand(rest);
 			}
 			case "ch":
 			case "channels": {
-				const { cmdCh } = await import("./channels-BwpN_8mu.js");
+				const { cmdCh } = await import("./channels-DQaZbare.js");
 				return cmdCh(rest);
 			}
 			case "term": {
-				const { cmdTerm } = await import("./terminal-CybRgMZu.js");
+				const { cmdTerm } = await import("./terminal-Dm32SXU-.js");
 				return cmdTerm(rest);
 			}
 			case "widget": {
-				const { cmdWidget } = await import("./widget-y5Bpvwsa.js");
+				const { cmdWidget } = await import("./widget-DXtaX3QR.js");
 				return cmdWidget(rest);
 			}
 			case "mint": {
-				const { cmdMint } = await import("./widget-y5Bpvwsa.js");
+				const { cmdMint } = await import("./widget-DXtaX3QR.js");
 				return cmdMint(rest);
 			}
 			case "serve": {
-				const { cmdServe } = await import("./serve-CpGJD2Kt.js");
+				const { cmdServe } = await import("./serve-ucVXOci1.js");
 				return cmdServe(rest);
 			}
 			case "tray": {
-				const { cmdTray } = await import("./trayApp-CmwwBg8v.js");
+				const { cmdTray } = await import("./trayApp-CZbwLK9t.js");
 				return cmdTray(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-B-iQKsQW.js");
+				const { cmdSetup } = await import("./setup-De7uYRZb.js");
 				return cmdSetup(rest);
 			}
 			case "ws": {
-				const { cmdWs } = await import("./ws-CH8GzcQn.js");
+				const { cmdWs } = await import("./ws-CqlS5JhN.js");
 				return cmdWs(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-i4o5SJ_h.js");
+				const { cmdSchedule } = await import("./schedule-DbLpjgl5.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-DWVw-Q7V.js");
+				const { cmdRemote } = await import("./remotes-Dg_JscKk.js");
 				return cmdRemote(rest);
 			}
 			case "expose": {
-				const { cmdExpose } = await import("./expose-BG17GV7D.js");
+				const { cmdExpose } = await import("./expose-BXn6My6A.js");
 				return cmdExpose(rest);
 			}
 			case "callback": {
-				const { cmdCallback } = await import("./callback-L4k-v2GG.js");
+				const { cmdCallback } = await import("./callback-Da7MRLh6.js");
 				return cmdCallback(rest);
 			}
 			case "reap":
@@ -1656,7 +1029,19 @@ async function buildAgentContextSection(self) {
 		latest: false,
 		cwdScope: null
 	})).find((r) => r.wrapper_pid === self.parent_pid) : void 0;
-	return `You are running inside an agent:\n  ${`You are agent pid ${self.pid} (${self.cli}) in ${shortenPath(self.cwd)}.`}\n  ${!hasParentPid ? `Top-level agent — no parent (started from a human shell or scheduler).` : parent ? `Spawned by agent pid ${parent.pid} (${parent.cli}) in ${shortenPath(parent.cwd)}.` : `Nested under a parent (wrapper pid ${self.parent_pid}) whose record isn't in the local registry.`}\n\nAs an agent, you can:\n  Spawn a sub-agent:\n    ay <cli> -- "<prompt>"                                  auto-links as your child\n    ay claude --model sonnet --advisor opus -- "<prompt>"   routine task\n    ay claude --model opus --advisor fable -- "<prompt>"    complex task\n    (pick --model by task complexity so easy tasks don't cost like hard ones;\n     --advisor is a claude-cli flag — only takes effect for claude/cy)\n  List agents (your children nest under your own pid in the tree):\n    ay ls --cwd ${shortenPath(self.cwd)}\n  Watch agent state changes, scoped to your workspace:\n    ay ls --watch --cwd ${shortenPath(self.cwd)}\n    (NDJSON stream of state changes across every matched agent — one watcher\n     for the whole fan-out instead of N \`ay status --watch\`es)\n  Read one sub-agent's output:\n    ay tail -f <pid>                        follow live output (no single command tails\n                                              many agents' content at once yet — loop\n                                              \`ay ls --json\` pids into per-pid \`ay tail\`)\n\n`;
+	const whoAmI = `You are agent pid ${self.pid} (${self.cli}) in ${shortenPath(self.cwd)}.`;
+	const parentLine = !hasParentPid ? `Top-level agent — no parent (started from a human shell or scheduler).` : parent ? `Spawned by agent pid ${parent.pid} (${parent.cli}) in ${shortenPath(parent.cwd)}.` : `Nested under a parent (wrapper pid ${self.parent_pid}) whose record isn't in the local registry.`;
+	const dutyLine = parent ? `  You owe it a report: \`ay send ${parent.agent_id || parent.pid} "..."\` when you finish, and\n  when you are blocked. It is not watching your terminal.\n` : ``;
+	return `You are running inside an agent:\n  ${whoAmI}\n  ${parentLine}\n` + dutyLine + `
+As an agent, you can:
+  Spawn a sub-agent:
+    ay <cli> -- "<prompt>"                                  auto-links as your child
+    ay claude --model sonnet --advisor opus -- "<prompt>"   routine task
+    ay claude --model opus --advisor fable -- "<prompt>"    complex task
+    (pick --model by task complexity so easy tasks don't cost like hard ones;
+     --advisor is a claude-cli flag — only takes effect for claude/cy)
+  List agents (your children nest under your own pid in the tree):
+    ay ls --cwd ${shortenPath(self.cwd)}\n  Watch agent state changes, scoped to your workspace:\n    ay ls --watch --cwd ${shortenPath(self.cwd)}\n    (NDJSON stream of state changes across every matched agent — one watcher\n     for the whole fan-out instead of N \`ay status --watch\`es)\n  Read one sub-agent's output:\n    ay tail -f <pid>                        follow live output (no single command tails\n                                              many agents' content at once yet — loop\n                                              \`ay ls --json\` pids into per-pid \`ay tail\`)\n\n`;
 }
 async function cmdHelp(managerCommands = true) {
 	const setupLine = managerCommands ? `  ay setup                            guided setup: pick a workspace, share to agent-yes.com\n` : ``;
@@ -2043,7 +1428,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-zQybN9IR.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-BDg0jjTs.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -3482,7 +2867,7 @@ async function cmdSend(rest) {
 	let suffix = "";
 	let nonce;
 	if (sender.agent && !isSlashCommand(body) && !raw) {
-		nonce = randomBytes$1(4).toString("hex");
+		nonce = randomBytes(4).toString("hex");
 		const identity = formatIdentity({
 			cwd: sender.agent.cwd,
 			pid: sender.agent.pid
@@ -4080,7 +3465,7 @@ async function cmdAttach(rest) {
 	const winsizeDir = path.join(ayHome, "winsize");
 	await mkdir(winsizeDir, { recursive: true });
 	const winsizePath = path.join(winsizeDir, String(record.pid));
-	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-CpGJD2Kt.js");
+	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-ucVXOci1.js");
 	const daemonBase = await resolveDaemonHttpBase().catch(() => null);
 	const daemonToken = daemonBase ? await loadTokenReadOnly().catch(() => null) ?? "" : "";
 	const capViewer = `attach:${process.pid}`;
@@ -4790,7 +4175,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-BL1tmxUK.js");
+		const { ensureDaemon } = await import("./notifyDaemon-BFzqcdN1.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4864,7 +4249,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-BL1tmxUK.js");
+	const daemon = await import("./notifyDaemon-BFzqcdN1.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4890,5 +4275,5 @@ async function cmdNotifyd(rest) {
 }
 
 //#endregion
-export { isTransientLockMkdirError as $, readLogForRender as A, resolveResumeArgs as B, isUnknownManagerToken as C, matchKeyword as D, listRecords as E, renderLogTailLines as F, stopTipForCli as G, runSubcommand as H, renderRawLog as I, writeKeysPaced as J, submitAndConfirm as K, renderRawLogLines as L, readPtysize as M, recentMessageEdges as N, menuSelectKeys as O, recentReadEdges as P, hostId as Q, resolveOne as R, isSubcommand as S, lastStdinAt as T, snapshotStatus as U, restartHintLines as V, stdinActivityPath as W, appendEvent as X, writeToIpc as Y, gcInboxes as Z, isAgentStuck as _, backoffWhileTyping as a, daemonLockOwnerPath as at, isPidAlive as b, controlCodeFromName as c, deriveLiveStatus as d, listInboxParents as et, extractBadges as f, finalizedLines as g, extractTaskCounts as h, TYPING_WINDOW_MS as i, daemonLockDir as it, readNotes as j, readAgentPtysize as k, cursorAbs as l, extractNeedsInput as m, MAX_RENDER_BYTES as n, readInbox as nt, cmdDeepseek as o, notifyDir as ot, extractMenu as p, waitForLogQuiet as q, READ_PAGE_DEFAULT as r, shouldStealLock as rt, cmdHelp as s, TYPING_BADGE as st, GRACEFUL_EXIT_COMMANDS as t, liveWatchers as tt, deriveLiveState as u, isBareManagerInvocation as v, isUserTyping as w, isSlashCommand as x, isExitRequest as y, resolveReadWindow as z };
-//# sourceMappingURL=subcommands-CQPnT5qu.js.map
+export { menuSelectKeys as A, resolveOne as B, isSubcommand as C, lastStdinAt as D, lastReadAt as E, recentMessageEdges as F, snapshotStatus as G, resolveResumeArgs as H, recentReadEdges as I, submitAndConfirm as J, stdinActivityPath as K, renderLogTailLines as L, readLogForRender as M, readNotes as N, listRecords as O, readPtysize as P, TYPING_BADGE as Q, renderRawLog as R, isSlashCommand as S, isUserTyping as T, restartHintLines as U, resolveReadWindow as V, runSubcommand as W, writeKeysPaced as X, waitForLogQuiet as Y, writeToIpc as Z, finalizedLines as _, TYPING_WINDOW_MS as a, isExitRequest as b, cmdHelp as c, deriveLiveState as d, deriveLiveStatus as f, extractTaskCounts as g, extractNeedsInput as h, READ_WINDOW_MS as i, readAgentPtysize as j, matchKeyword as k, controlCodeFromName as l, extractMenu as m, MAX_RENDER_BYTES as n, backoffWhileTyping as o, extractBadges as p, stopTipForCli as q, READ_PAGE_DEFAULT as r, cmdDeepseek as s, GRACEFUL_EXIT_COMMANDS as t, cursorAbs as u, isAgentStuck as v, isUnknownManagerToken as w, isPidAlive as x, isBareManagerInvocation as y, renderRawLogLines as z };
+//# sourceMappingURL=subcommands-DtF31RoW.js.map