agent-yes 1.194.0 → 1.196.0

package/dist/{subcommands-Ba0V9EEH.js → subcommands-s74ViJcI.js}

@@ -161,6 +161,94 @@ function parseTaskCounts(lines) {
 	return best;
 }
 
+//#endregion
+//#region ts/messageLog.ts
+/**
+* Durable inter-agent message log.
+*
+* Every `ay send` that carries a real body is recorded twice — from the two
+* ends' points of view — as append-only JSONL colocated with each agent's
+* project dir (the same `<cwd>/.agent-yes/` convention the session logs use):
+*
+*   - the SENDER's   `<from.cwd>/.agent-yes/outbox.jsonl`
+*   - the RECIPIENT's `<to.cwd>/.agent-yes/inbox.jsonl`
+*
+* A single cwd may host several agents, so records carry the stable `agent_id`
+* (falling back to `pid`) of each end; `ay msgs` filters a mailbox down to one
+* agent by that key. Reading needs no lock (last line wins isn't relevant — a
+* message log keeps every entry); writing is best-effort and never blocks or
+* fails a send.
+*/
+/** Keep at most this many lines per mailbox; older entries are compacted away. */
+const MAILBOX_MAX_LINES = 2e3;
+/** Path to a cwd's mailbox file (`<cwd>/.agent-yes/{inbox,outbox}.jsonl`). */
+function mailboxPath(cwd, box) {
+	return path.join(cwd, ".agent-yes", `${box}.jsonl`);
+}
+/** Whether a mail party is the agent identified by (agentId, pid). Prefers the
+* stable agent_id (survives restart); falls back to pid for legacy records. */
+function partyMatches(party, agentId, pid) {
+	if (!party) return false;
+	if (agentId && party.agent_id && party.agent_id === agentId) return true;
+	if (typeof pid === "number" && party.pid === pid) return true;
+	return false;
+}
+async function appendCapped(filePath, record) {
+	await mkdir(path.dirname(filePath), { recursive: true });
+	await appendFile(filePath, JSON.stringify(record) + "\n");
+	const lines = (await readFile(filePath, "utf-8").catch(() => "")).split("\n").filter((l) => l.trim());
+	if (lines.length > MAILBOX_MAX_LINES) await writeFile(filePath, lines.slice(lines.length - MAILBOX_MAX_LINES).join("\n") + "\n");
+}
+/**
+* Record the SENDER's view in its outbox. Best-effort — a filesystem error is
+* logged and swallowed so persistence never breaks a send. The outbox lives
+* under `from.cwd`; a human sender (from === null) writes under `process.cwd()`.
+*/
+async function recordOutbox(record) {
+	const outCwd = record.from?.cwd ?? process.cwd();
+	try {
+		await appendCapped(mailboxPath(outCwd, "outbox"), record);
+	} catch (err) {
+		logger.debug(`[messageLog] outbox append failed: ${err}`);
+	}
+}
+/** Record the RECIPIENT's view in its inbox (under `to.cwd`). Best-effort. */
+async function recordInbox(record) {
+	try {
+		await appendCapped(mailboxPath(record.to.cwd, "inbox"), record);
+	} catch (err) {
+		logger.debug(`[messageLog] inbox append failed: ${err}`);
+	}
+}
+/**
+* Record a same-host message in both mailboxes — the sender's outbox and the
+* recipient's inbox both live on this machine. For a message that crossed the
+* wire, each end calls `recordOutbox`/`recordInbox` on its own host instead.
+*/
+async function recordMessage(record) {
+	await recordOutbox(record);
+	await recordInbox(record);
+}
+/** Read and parse a cwd's mailbox, oldest first. Missing/corrupt lines skipped. */
+async function readMailbox(cwd, box) {
+	let raw;
+	try {
+		raw = await readFile(mailboxPath(cwd, box), "utf-8");
+	} catch {
+		return [];
+	}
+	const out = [];
+	for (const line of raw.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		try {
+			const rec = JSON.parse(t);
+			if (rec && typeof rec.at === "number" && rec.to) out.push(rec);
+		} catch {}
+	}
+	return out;
+}
+
 //#endregion
 //#region ts/badges.ts
 const BADGE_DEFS = [
@@ -988,6 +1076,40 @@ async function recentReadEdges(windowMs = READ_WINDOW_MS) {
 	}
 	return out;
 }
+/**
+* Scan every live agent's outbox for sends within `windowMs` and return them as
+* directional edges (newest `at` per by→target pair wins). Bounded by the number
+* of distinct agent cwds — the outbox is per-cwd, so each dir is read once.
+*/
+async function recentMessageEdges(windowMs = READ_WINDOW_MS) {
+	const now = Date.now();
+	const records = await listRecords(void 0, {
+		all: true,
+		active: false,
+		json: false,
+		latest: false,
+		cwdScope: null
+	});
+	const cwds = [...new Set(records.map((r) => r.cwd).filter(Boolean))];
+	const best = /* @__PURE__ */ new Map();
+	await Promise.all(cwds.map(async (cwd) => {
+		for (const rec of await readMailbox(cwd, "outbox")) {
+			if (now - rec.at > windowMs) continue;
+			const by = rec.from?.pid;
+			const target = rec.to?.pid;
+			if (!by || !target || by === target) continue;
+			const key = `${by}\0${target}`;
+			const prev = best.get(key);
+			if (!prev || rec.at > prev.at) best.set(key, {
+				by,
+				target,
+				at: rec.at,
+				kind: rec.kind
+			});
+		}
+	}));
+	return [...best.values()];
+}
 async function resolveSender() {
 	const envPid = process.env.AGENT_YES_PID ? Number(process.env.AGENT_YES_PID) : null;
 	if (!envPid || Number.isNaN(envPid)) return null;
@@ -1076,6 +1198,7 @@ const SUBCOMMANDS = new Set([
 	"tail",
 	"head",
 	"send",
+	"msgs",
 	"key",
 	"select",
 	"spawn",
@@ -1138,6 +1261,7 @@ async function runSubcommand(argv) {
 			case "tail": return await cmdRead(rest, { mode: "tail" });
 			case "head": return await cmdRead(rest, { mode: "head" });
 			case "send": return await cmdSend(rest);
+			case "msgs": return await cmdMsgs(rest);
 			case "key": return await cmdKey(rest);
 			case "select": return await cmdSelect(rest);
 			case "spawn": return await cmdSpawn(rest);
@@ -1147,15 +1271,15 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-hA23xPpg.js");
+				const { cmdServe } = await import("./serve-D0-LoTfw.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-C6grPf1R.js");
+				const { cmdSetup } = await import("./setup-BC1VjTOf.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-MQZjDaY6.js");
+				const { cmdSchedule } = await import("./schedule-rvMgc0tA.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -1200,7 +1324,7 @@ async function cmdHelp(managerCommands = true) {
 	const setupLine = managerCommands ? `  ay setup                            guided setup: pick a workspace, share to agent-yes.com\n` : ``;
 	const self = process.env.AGENT_YES_PID ? await resolveSender() : null;
 	const agentSection = self ? await buildAgentContextSection(self) : "";
-	process.stdout.write(agentSection + "ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay key <keyword> <key...>           send raw keystrokes (down/up/enter/esc/…) — drives menus\n  ay select <keyword> <N>             pick option N of a needs_input selection menu\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay restart <keyword> [--fresh]      stop (if live) + relaunch resuming the session; --fresh replays the prompt\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay expose <port>                    share localhost:<port> at https://<id>.agent-yes.com (private link)\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
+	process.stdout.write(agentSection + "ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay msgs [keyword] [--in|--out]      inter-agent message log (sent + received)\n  ay key <keyword> <key...>           send raw keystrokes (down/up/enter/esc/…) — drives menus\n  ay select <keyword> <N>             pick option N of a needs_input selection menu\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay restart <keyword> [--fresh]      stop (if live) + relaunch resuming the session; --fresh replays the prompt\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay expose <port>                    share localhost:<port> at https://<id>.agent-yes.com (private link)\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
 	return 0;
 }
 function matchKeyword(record, keyword) {
@@ -1480,10 +1604,18 @@ async function runRemoteSend(remote, msg, code) {
 		process.stderr.write("remote send requires a keyword (e.g. token@host:port:keyword)\n");
 		return 1;
 	}
+	const sender = await senderContext();
+	const from = sender.agent ? {
+		pid: sender.agent.pid,
+		cli: sender.agent.cli,
+		cwd: sender.agent.cwd,
+		agent_id: sender.agent.agent_id
+	} : null;
 	const res = await remotePost(remote, "/api/send", {
 		keyword,
 		msg,
-		code
+		code,
+		from
 	});
 	if (!res.ok) {
 		process.stderr.write(`remote error ${res.status}: ${await res.text()}\n`);
@@ -1491,6 +1623,21 @@ async function runRemoteSend(remote, msg, code) {
 	}
 	const data = await res.json();
 	process.stdout.write(`sent to remote pid ${data.pid} (${remote.url}  ${keyword})\n`);
+	if (msg && msg !== "-") await recordOutbox({
+		at: Date.now(),
+		from,
+		to: {
+			pid: data.pid,
+			cli: data.cli ?? keyword,
+			cwd: data.cwd ?? "",
+			agent_id: data.agentId
+		},
+		body: msg,
+		code: code.toLowerCase() === "enter" ? void 0 : code.toLowerCase(),
+		confirmed: true,
+		wrapped: false,
+		remote: remote.url
+	});
 	return 0;
 }
 /**
@@ -2929,8 +3076,9 @@ async function cmdSend(rest) {
 	const replyTarget = sender.agent?.agent_id || sender.agent?.pid;
 	let prefix = "";
 	let suffix = "";
+	let nonce;
 	if (sender.agent && !isSlashCommand(body)) {
-		const nonce = randomBytes$1(4).toString("hex");
+		nonce = randomBytes$1(4).toString("hex");
 		prefix = `<ay-msg ${nonce} from ${sender.agent.cli} #${sender.agent.pid} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${replyTarget} "...">\n`;
 		suffix = `\n</ay-msg ${nonce}>`;
 	}
@@ -2957,6 +3105,26 @@ async function cmdSend(rest) {
 	const payload = body + trailing;
 	const status = confirmed ? "sent" : "sent but NOT confirmed submitted";
 	process.stdout.write(`${status} to pid ${record.pid} (${record.cli}): ${truncate(payload, 80)}\n`);
+	if (body) await recordMessage({
+		at: Date.now(),
+		nonce,
+		from: sender.agent ? {
+			pid: sender.agent.pid,
+			cli: sender.agent.cli,
+			cwd: sender.agent.cwd,
+			agent_id: sender.agent.agent_id
+		} : null,
+		to: {
+			pid: record.pid,
+			cli: record.cli,
+			cwd: record.cwd,
+			agent_id: record.agent_id
+		},
+		body,
+		code: trailing === "\r" ? void 0 : codeName,
+		confirmed,
+		wrapped: Boolean(nonce)
+	});
 	if (!confirmed) process.stderr.write(`\nwarning: couldn't confirm the CLI acted on it after ${SEND_SUBMIT_MAX_RETRIES + 1} attempt(s) — it may still be sitting unsubmitted in the prompt. Last screen:\n` + lastScreen.slice(-8).map((l) => `  ${l}`).join("\n") + "\n");
 	const replyHint = sender.agent ? `  ay send ${replyTarget} "..."              # reply to sender\n` : "";
 	process.stderr.write(`\n` + replyHint + `  ay tail ${record.pid}                  # watch output\n  ay ls                                  # list all agents\n`);
@@ -2966,11 +3134,134 @@ async function cmdSend(rest) {
 	}
 	return confirmed ? 0 : 1;
 }
+/**
+* `ay msgs [keyword]` — show the inter-agent messages an agent sent and
+* received. With no keyword it uses THIS caller's context (the agent running
+* `ay msgs`, or the human shell's cwd); with a keyword it resolves one agent and
+* reads that agent's mailboxes. Newest last, like a chat log.
+*/
+async function cmdMsgs(rest) {
+	const argv = await yargs(rest).usage("Usage: ay msgs [keyword] [--in|--out] [-n N] [--json]").option("in", {
+		type: "boolean",
+		default: false,
+		description: "Only received messages"
+	}).option("out", {
+		type: "boolean",
+		default: false,
+		description: "Only sent messages"
+	}).option("n", {
+		type: "number",
+		description: "Show the last N messages (default 50)"
+	}).option("json", {
+		type: "boolean",
+		default: false,
+		description: "Emit raw JSONL records"
+	}).option("all", {
+		type: "boolean",
+		default: false,
+		description: "Include exited agents"
+	}).option("latest", {
+		type: "boolean",
+		default: false,
+		description: "Use most recent match when multiple match"
+	}).option("cwd", {
+		type: "string",
+		description: "Restrict to agents under this dir"
+	}).help(false).version(false).exitProcess(false).parseAsync();
+	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
+	let ownerCwd;
+	let ownerAgentId;
+	let ownerPid;
+	let ownerLabel;
+	if (keyword) {
+		const record = await resolveOne(keyword, {
+			all: argv.all,
+			active: false,
+			json: false,
+			latest: argv.latest,
+			cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
+		});
+		ownerCwd = record.cwd;
+		ownerAgentId = record.agent_id;
+		ownerPid = record.pid;
+		ownerLabel = `pid ${record.pid} (${record.cli})`;
+	} else {
+		const sender = await senderContext();
+		ownerCwd = sender.agent?.cwd ?? process.cwd();
+		ownerAgentId = sender.agent?.agent_id;
+		ownerPid = sender.agent?.pid;
+		ownerLabel = sender.agent ? `pid ${sender.agent.pid} (${sender.agent.cli})` : "this shell";
+	}
+	const isOwner = (party) => ownerAgentId || ownerPid ? partyMatches(party, ownerAgentId, ownerPid) : party === null;
+	const messages = [];
+	if (!argv.in) {
+		for (const rec of await readMailbox(ownerCwd, "outbox")) if (isOwner(rec.from)) messages.push({
+			dir: "out",
+			rec
+		});
+	}
+	if (!argv.out) {
+		for (const rec of await readMailbox(ownerCwd, "inbox")) if (isOwner(rec.to)) messages.push({
+			dir: "in",
+			rec
+		});
+	}
+	messages.sort((a, b) => a.rec.at - b.rec.at);
+	const limit = argv.n !== void 0 && Number.isFinite(argv.n) && argv.n > 0 ? Math.floor(argv.n) : 50;
+	const shown = messages.slice(-limit);
+	if (argv.json) {
+		for (const { dir, rec } of shown) process.stdout.write(JSON.stringify({
+			dir,
+			...rec
+		}) + "\n");
+		return 0;
+	}
+	if (shown.length === 0) {
+		process.stderr.write(`no messages for ${ownerLabel}.\n`);
+		return 0;
+	}
+	for (const { dir, rec } of shown) {
+		const when = new Date(rec.at).toLocaleTimeString();
+		const peer = dir === "out" ? `→ ${rec.to.cli} #${rec.to.pid}` : `← ${rec.from ? `${rec.from.cli} #${rec.from.pid}` : "human"}`;
+		const via = rec.remote ? ` (via ${rec.remote})` : "";
+		const flag = rec.confirmed === false ? " (unconfirmed)" : "";
+		const line = (rec.kind ? `[${rec.kind}] ` : "") + truncate(rec.body.replace(/\s+/g, " "), 100);
+		process.stdout.write(`${when}  ${peer.padEnd(20)}${via}${flag}  ${line}\n`);
+	}
+	return 0;
+}
 async function resolveWritableAgent(keyword, opts) {
 	const record = await resolveOne(keyword, opts);
 	if (!record.fifo_file) throw new Error(`pid ${record.pid}: no fifo_file recorded — this agent didn't register a stdin FIFO (an older agent, or one not started with --stdpush). Restarting it (ay restart ${record.pid}) re-registers one.`);
 	return record;
 }
+/**
+* Record an `ay key` / `ay select` stdin write in the message log, same as a
+* text send but tagged with its `kind` (and `body` = the keystroke names /
+* chosen option). Key/select are local-only (no remote wire), so both mailboxes
+* are on this host — recordMessage writes both. Best-effort.
+*/
+async function recordKeyEvent(sender, record, kind, body) {
+	await recordMessage({
+		at: Date.now(),
+		from: sender.agent ? {
+			pid: sender.agent.pid,
+			cli: sender.agent.cli,
+			cwd: sender.agent.cwd,
+			agent_id: sender.agent.agent_id
+		} : null,
+		to: {
+			pid: record.pid,
+			cli: record.cli,
+			cwd: record.cwd,
+			agent_id: record.agent_id
+		},
+		kind,
+		body,
+		confirmed: true,
+		wrapped: false
+	});
+}
 async function cmdKey(rest) {
 	const argv = await yargs(rest).usage("Usage: ay key <keyword> <key...> [options]\n\nSend raw named keystrokes to a live agent's TUI — no message framing, no\nauto-Enter. Drives selection menus and other interactive prompts that a\nplain `ay send` (text + Enter) can't. Keys are paced so the CLI registers\neach as a discrete event, not a paste.\n\nKeys: up down left right enter esc tab space backspace delete home end\n      pageup pagedown ctrl-c ctrl-d ctrl-y  raw:0xNN\n\nExamples:\n  ay key 1234 down down enter    # move the menu cursor down twice, confirm\n  ay key 1234 esc                # dismiss a menu\n  ay key 1234 raw:0x1b           # a literal ESC byte").option("pace", {
 		type: "number",
@@ -3003,9 +3294,10 @@ async function cmdKey(rest) {
 		latest: argv.latest,
 		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	});
-	await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
+	const sender = await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
 	await writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace));
 	process.stdout.write(`sent to pid ${record.pid} (${record.cli}): ${keyNames.join(" ")}\n`);
+	await recordKeyEvent(sender, record, "key", keyNames.join(" "));
 	return 0;
 }
 async function cmdSelect(rest) {
@@ -3048,7 +3340,7 @@ async function cmdSelect(rest) {
 		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	});
 	if (!record.log_file) throw new Error(`pid ${record.pid}: no log_file recorded — can't read the menu to select from.`);
-	await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
+	const sender = await enforceSendGuards(record, Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1");
 	const menu = await extractMenu(record.log_file, record.cli);
 	if (!menu) throw new Error(`pid ${record.pid} (${record.cli}) is not parked on a selection menu (not needs_input).\n  Check with:  ay status ${record.pid}`);
 	if (menu.options.length > 0 && !menu.options.includes(n)) throw new Error(`option ${n} is out of range — this menu offers ${menu.options.join(", ")}.`);
@@ -3057,6 +3349,7 @@ async function cmdSelect(rest) {
 	const delta = n - menu.cursor;
 	const moved = delta === 0 ? "cursor already there" : `${Math.abs(delta)}× ${delta > 0 ? "down" : "up"}`;
 	process.stdout.write(`pid ${record.pid} (${record.cli}): selected option ${n} (${moved} + enter)\n`);
+	await recordKeyEvent(sender, record, "select", `option ${n}`);
 	if (argv.wait) {
 		const ok = await waitForNeedsInputClear(record, Math.max(1, argv.timeout) * 1e3);
 		process.stdout.write(ok ? `  menu cleared — selection accepted.\n` : `  still needs_input after ${argv.timeout}s — re-check with 'ay status ${record.pid}'.\n`);
@@ -4004,7 +4297,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-Deisyrbn.js");
+		const { ensureDaemon } = await import("./notifyDaemon-BdOeFIVl.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4078,7 +4371,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-Deisyrbn.js");
+	const daemon = await import("./notifyDaemon-BdOeFIVl.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4104,5 +4397,5 @@ async function cmdNotifyd(rest) {
 }
 
 //#endregion
-export { TYPING_BADGE as $, renderRawLogLines as A, waitForLogQuiet as B, matchKeyword as C, recentReadEdges as D, readPtysize as E, runSubcommand as F, hostId as G, writeToIpc as H, snapshotStatus as I, readInbox as J, listInboxParents as K, stdinActivityPath as L, resolveReadWindow as M, resolveResumeArgs as N, renderLogTailLines as O, restartHintLines as P, notifyDir as Q, stopTipForCli as R, listRecords as S, readNotes as T, appendEvent as U, writeKeysPaced as V, gcInboxes as W, daemonLockDir as X, shouldStealLock as Y, daemonLockOwnerPath as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, extractNeedsInput as f, isExitRequest as g, isAgentStuck as h, backoffWhileTyping as i, resolveOne as j, renderRawLog as k, deriveLiveStatus as l, finalizedLines as m, READ_PAGE_DEFAULT as n, controlCodeFromName as o, extractTaskCounts as p, liveWatchers as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, submitAndConfirm as z };
-//# sourceMappingURL=subcommands-Ba0V9EEH.js.map
+export { notifyDir as $, renderRawLog as A, submitAndConfirm as B, matchKeyword as C, recentMessageEdges as D, readPtysize as E, restartHintLines as F, gcInboxes as G, writeKeysPaced as H, runSubcommand as I, liveWatchers as J, hostId as K, snapshotStatus as L, resolveOne as M, resolveReadWindow as N, recentReadEdges as O, resolveResumeArgs as P, daemonLockOwnerPath as Q, stdinActivityPath as R, listRecords as S, readNotes as T, writeToIpc as U, waitForLogQuiet as V, appendEvent as W, shouldStealLock as X, readInbox as Y, daemonLockDir as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, TYPING_BADGE as et, extractNeedsInput as f, isExitRequest as g, isAgentStuck as h, backoffWhileTyping as i, renderRawLogLines as j, renderLogTailLines as k, deriveLiveStatus as l, finalizedLines as m, READ_PAGE_DEFAULT as n, controlCodeFromName as o, extractTaskCounts as p, listInboxParents as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, recordInbox as tt, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, stopTipForCli as z };
+//# sourceMappingURL=subcommands-s74ViJcI.js.map

package/dist/{ts-6JcbtJh1.js → ts-CP17kUI1.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-DDNKcQRx.js";
+import { r as getInstalledPackage } from "./versionChecker-DTssk7cU.js";
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CNMl13dC.js";
 import { t as PidStore } from "./pidStore-BIvsBQ8X.js";
@@ -1824,4 +1824,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-6JcbtJh1.js.map
+//# sourceMappingURL=ts-CP17kUI1.js.map

package/dist/{versionChecker-DDNKcQRx.js → versionChecker-DTssk7cU.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.194.0";
+var version = "1.196.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-DDNKcQRx.js.map
+//# sourceMappingURL=versionChecker-DTssk7cU.js.map