agent-yes 1.267.2 → 1.269.1

package/dist/{subcommands-DJpVXIb6.js → subcommands-03ghe-aZ.js}

@@ -2,121 +2,22 @@ import { t as invokedCliName } from "./invokedCli-uqM2YYA7.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 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-DdAfueOu.js";
+import { t as loadSharedCliDefaults } from "./configShared-DYxlvrH0.js";
+import { t as formatIdentity } from "./identity-CLaJ9-uE.js";
+import { n as isWorkingScreen, r as parseMenu, t as classifyNeedsInput } from "./needsInput-DhfIwxse.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-Dus2D1XA.js";
+import { n as isWebrtcSpec } from "./webrtcLink-B72AQ2eb.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-IzQHupeo.js";
 import { spawn } from "child_process";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
-import { readFileSync } from "node:fs";
-import path$1 from "node:path";
-import { homedir as homedir$1, hostname as hostname$1, userInfo as userInfo$1 } from "node:os";
+import { lock } from "proper-lockfile";
 import { fileURLToPath } from "node:url";
 import { randomBytes } from "crypto";
 
-//#region ts/identity.ts
-/**
-* The standardized agent identity string:
-*
-*   <username>@<hostname>:<path>:<branch>#<pid>
-*   e.g.  sno@Mac:~/ws/symval/symval/tree/crm:main#30402
-*
-* One line answers "who is this agent" across every surface that names one —
-* the `ay send` envelope header, `ay whoami`, logs. The branch segment usually
-* carries the lane name for free (worktree checkouts like `crm-yamamoto-wifi`
-* or `fix/t173-tone-core` name their purpose), which is why there is no
-* separate role concept.
-*
-* Parsing (right-to-left, for consumers that need it): `#<pid>` from the end;
-* the branch is after the last `:` (git forbids `:` in ref names); the
-* username is before the first `@`; the hostname is between that `@` and the
-* next `:` (hostnames contain no `:`). The path in the middle may itself
-* contain `@`/`:` (Windows drives), which is why parsing anchors on the ends.
-*
-* Every token is clamped before rendering: the identity is embedded in the
-* `<ay-msg …>` envelope's OPEN tag, which is not nonce-protected — whitespace
-* or `>` in a token could forge header structure.
-*/
-/** Replace anything outside a conservative charset so a token can never break
-* out of the envelope header line. Collapses runs to a single `-`. */
-function safeToken(raw, max) {
-	return raw.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max);
-}
-/** The local username, header-safe ("John Smith" → "John-Smith"). */
-function localUser() {
-	try {
-		return safeToken(userInfo$1().username, 32) || "unknown";
-	} catch {
-		return "unknown";
-	}
-}
-/** The local hostname's first label ("Macs-MBP.local" → "Macs-MBP"). */
-function localHost() {
-	return safeToken(hostname$1().split(".")[0] ?? "", 32) || "unknown";
-}
-/**
-* The checked-out branch of the git repo containing `cwd`, or a short commit
-* id when detached, or null when `cwd` is not inside a git checkout. Pure
-* file reads — never spawns git — so it is cheap enough to run on every send:
-* walk up to the nearest `.git`, follow a worktree's `gitdir:` indirection
-* file, then parse `HEAD`.
-*/
-function readGitBranch(cwd) {
-	let dir = path$1.resolve(cwd);
-	for (let depth = 0; depth < 32; depth++) {
-		const dotGit = path$1.join(dir, ".git");
-		let gitDir = null;
-		try {
-			const content = readFileSync(dotGit, "utf8");
-			const m = /^gitdir:\s*(.+)\s*$/m.exec(content);
-			gitDir = m ? path$1.resolve(dir, m[1].trim()) : null;
-		} catch (err) {
-			if (err?.code === "EISDIR") gitDir = dotGit;
-		}
-		if (gitDir) try {
-			const head = readFileSync(path$1.join(gitDir, "HEAD"), "utf8").trim();
-			const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
-			if (ref) return safeBranch(ref[1]);
-			if (/^[0-9a-f]{40}$/i.test(head)) return head.slice(0, 12);
-			return null;
-		} catch {
-			return null;
-		}
-		const parent = path$1.dirname(dir);
-		if (parent === dir) return null;
-		dir = parent;
-	}
-	return null;
-}
-/** Branch names never contain `:`/space/`~`/`^` (git forbids them), but they
-* DO allow `/` and `#` — keep `/` (readable, unambiguous: parsing anchors on
-* `#<pid>` at the end) and clamp everything else defensively. */
-function safeBranch(raw) {
-	return raw.replace(/[^A-Za-z0-9._/#-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
-}
-/** Abbreviate the home directory to `~`, mirroring how `ay ls` prints cwds. */
-function tildify(p) {
-	const home = homedir$1();
-	return p.startsWith(home) ? "~" + p.slice(home.length) : p;
-}
-/**
-* Render the standardized identity for an agent. `user`/`host` default to the
-* local machine (correct for the envelope: the sending wrapper runs on the
-* agent's own host), `branch` auto-detects from `cwd` unless given.
-*/
-function formatIdentity(parts) {
-	const user = parts.user ?? localUser();
-	const host = parts.host ?? localHost();
-	const branch = parts.branch === void 0 ? readGitBranch(parts.cwd) : parts.branch;
-	return `${user}@${host}:${tildify(parts.cwd)}${branch ? `:${branch}` : ""}#${parts.pid}`;
-}
-
-//#endregion
 //#region ts/agentTree.ts
 /**
 * Link records into a forest via parent_pid === wrapper_pid. Records whose
@@ -469,6 +370,117 @@ function buildStoredResult(pid, result, writtenAt) {
 	};
 }
 
+//#endregion
+//#region ts/ipcLock.ts
+/**
+* Cross-process mutual exclusion for writing to ONE agent's stdin.
+*
+* What this guarantees is ATOMICITY, not ordering. Two independent senders
+* (two console viewers, an `ay send` racing a viewer, two `ay` processes) have
+* no defined arrival order at the host, and nothing here invents one —
+* per-client ordering is the browser's single-in-flight send queue
+* (`createInputSender` in lab/ui/console-logic.js). What this prevents is the
+* two of them SPLICING into each other:
+*
+*   - `writeToIpc` does not write a payload in one syscall. A FIFO's kernel
+*     buffer is small (~8KB), so it loops on EAGAIN/partial writes while the
+*     agent drains its stdin. POSIX only promises atomicity up to PIPE_BUF
+*     (512 bytes on macOS), so two concurrent writers interleave BYTES in the
+*     middle of each other's payloads — not messages arriving in a surprising
+*     order, but one message cut in half by another.
+*   - Several input actions are inherently multi-write: `ay send` writes the
+*     body, waits ~200ms for the CLI's paste handling to settle, then writes
+*     the Enter. `ay key` paces a key sequence 40ms apart. `ay stop` writes a
+*     graceful command, Enter, then Ctrl-C twice. Every gap in those is a
+*     window where another writer's bytes can land mid-transaction — which is
+*     how a keystroke ends up fused into the middle of a sent message, or a
+*     menu navigation gets a stray character.
+*
+* So the unit protected here is the TRANSACTION, not the write: callers wrap
+* a whole logical action, and `writeToIpc` itself stays lock-free (and thus
+* non-reentrant by construction).
+*
+* FAIL-OPEN is deliberate. Making input delivery depend on acquiring a lock
+* would add a brand-new way for an agent to become unreachable, which is worse
+* than the splicing this fixes. If the lock cannot be acquired within the
+* budget, the transaction proceeds unprotected with a warning — exactly the
+* behavior that existed before this module, so this can only improve on it.
+*/
+/**
+* How long a legitimate holder may hold before we give up waiting.
+*
+* Derived, not picked: one `writeToIpc` can legitimately take up to
+* `IPC_WRITE_TIMEOUT_MS` (10s) when the agent's stdin is backed up — and that
+* is precisely when splicing is most likely, so a short budget would abandon
+* the guarantee in the one case that needs it. A wait this long only ever
+* materialises against an agent that is already not draining, where the
+* waiter's own write would be hanging anyway. Crashed holders are handled by
+* `stale` below, not by this budget.
+*/
+const ACQUIRE_BUDGET_MS = 12e3;
+/**
+* When to steal a lock as abandoned. Must exceed the longest LEGITIMATE hold,
+* or a slow-but-alive sender gets its lock stolen mid-transaction — which
+* would reintroduce exactly the splice this module prevents. The worst legal
+* case is `ay send` against a wedged reader: two 10s writes plus the 200ms
+* settle gap.
+*/
+const STALE_MS = 3e4;
+const RETRY_MS = 15;
+/**
+* Targets this process currently holds. `proper-lockfile` is not reentrant: a
+* nested acquire from the same process on the same target would block until
+* the budget expired, wedging input for 12s. Nesting is not expected today,
+* but the cost of being wrong is "this agent accepts no input", so the guard
+* is cheaper than the audit.
+*/
+const heldByThisProcess = /* @__PURE__ */ new Set();
+/** Lock target for an agent's stdin, keyed by pid.
+*
+* Under `$AGENT_YES_HOME`, NOT beside the FIFO: on Windows the "FIFO" is a
+* named pipe (`\\.\pipe\…`), which has no containing directory to put a
+* sibling lockfile in. Keying by pid also stays stable if the fifo path
+* changes shape between runtimes.
+*/
+function ipcLockTarget(pid) {
+	return path.join(agentYesHome(), "locks", `ipc-${pid}`);
+}
+/**
+* Run `fn` with exclusive access to `pid`'s stdin across processes.
+*
+* `onFallback` is called (once) if the lock could not be acquired and `fn` is
+* about to run unprotected — callers use it to warn. `fn`'s own errors
+* propagate unchanged, and the lock is always released.
+*/
+async function withIpcLock(pid, fn, onFallback) {
+	if (heldByThisProcess.has(pid)) return fn();
+	let release;
+	const target = ipcLockTarget(pid);
+	try {
+		await mkdir(path.dirname(target), { recursive: true });
+		release = await lock(target, {
+			lockfilePath: `${target}.lock`,
+			realpath: false,
+			stale: STALE_MS,
+			retries: {
+				retries: Math.ceil(ACQUIRE_BUDGET_MS / RETRY_MS),
+				minTimeout: RETRY_MS,
+				maxTimeout: RETRY_MS
+			}
+		});
+	} catch (err) {
+		onFallback?.(err instanceof Error ? err.message : String(err));
+		return fn();
+	}
+	heldByThisProcess.add(pid);
+	try {
+		return await fn();
+	} finally {
+		heldByThisProcess.delete(pid);
+		await release().catch(() => {});
+	}
+}
+
 //#endregion
 //#region ts/subcommands.ts
 /**
@@ -789,6 +801,8 @@ const SUBCOMMANDS = new Set([
 	"restart",
 	"note",
 	"todo",
+	"ask",
+	"answer",
 	"ch",
 	"channels",
 	"term",
@@ -893,7 +907,7 @@ async function runSubcommand(argv) {
 		switch (sub) {
 			case "ls":
 			case "list": return await cmdLs(rest);
-			case "ps": return await (await import("./cmdPs-D8gsRFVV.js")).cmdPs(rest);
+			case "ps": return await (await import("./cmdPs-CVnlflxP.js")).cmdPs(rest);
 			case "status": return await cmdStatus(rest);
 			case "whoami": return await cmdWhoami(rest);
 			case "result": return await cmdResult(rest);
@@ -904,7 +918,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-BoZPJ2ah.js")).cmdHist(rest);
+			case "history": return await (await import("./hist-DiOYRXuD.js")).cmdHist(rest);
 			case "send": return await cmdSend(rest);
 			case "msgs": return await cmdMsgs(rest);
 			case "key": return await cmdKey(rest);
@@ -915,57 +929,72 @@ async function runSubcommand(argv) {
 			case "exit": return await cmdExit(rest);
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
+			case "ask":
+			case "answer": {
+				const { runAskSubcommand, runAnswerSubcommand } = await import("./askCli-Bbxt9Umz.js");
+				const deps = {
+					resolveAgent: (keyword) => resolveOne(keyword, {
+						all: true,
+						active: false,
+						json: false,
+						latest: false,
+						cwdScope: null
+					}),
+					send: cmdSend
+				};
+				return sub === "ask" ? await runAskSubcommand(rest, deps) : await runAnswerSubcommand(rest, deps);
+			}
 			case "todo": {
-				const { runTodoSubcommand } = await import("./todoCli-BYGZ7_C5.js");
+				const { runTodoSubcommand } = await import("./todoCli-DUoxA1dh.js");
 				return runTodoSubcommand(rest);
 			}
 			case "ch":
 			case "channels": {
-				const { cmdCh } = await import("./channels-DQaZbare.js");
+				const { cmdCh } = await import("./channels-3gz9gHP7.js");
 				return cmdCh(rest);
 			}
 			case "term": {
-				const { cmdTerm } = await import("./terminal-CRLPUaKF.js");
+				const { cmdTerm } = await import("./terminal-DrCP-200.js");
 				return cmdTerm(rest);
 			}
 			case "widget": {
-				const { cmdWidget } = await import("./widget-DtZ1WXkf.js");
+				const { cmdWidget } = await import("./widget-BM03OkC1.js");
 				return cmdWidget(rest);
 			}
 			case "mint": {
-				const { cmdMint } = await import("./widget-DtZ1WXkf.js");
+				const { cmdMint } = await import("./widget-BM03OkC1.js");
 				return cmdMint(rest);
 			}
 			case "serve": {
-				const { cmdServe } = await import("./serve-BqRNIxeq.js");
+				const { cmdServe } = await import("./serve-BaHCO0bU.js");
 				return cmdServe(rest);
 			}
 			case "tray": {
-				const { cmdTray } = await import("./trayApp-CoD89Y1_.js");
+				const { cmdTray } = await import("./trayApp-BDMzlxRo.js");
 				return cmdTray(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-GYkQYxlf.js");
+				const { cmdSetup } = await import("./setup-B8EL0SWL.js");
 				return cmdSetup(rest);
 			}
 			case "ws": {
-				const { cmdWs } = await import("./ws-CiR2nOD3.js");
+				const { cmdWs } = await import("./ws-6l7Wb_0r.js");
 				return cmdWs(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-Bmh5uaDr.js");
+				const { cmdSchedule } = await import("./schedule-D1CNvuKT.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-M8FbM92D.js");
+				const { cmdRemote } = await import("./remotes-BiftUp09.js");
 				return cmdRemote(rest);
 			}
 			case "expose": {
-				const { cmdExpose } = await import("./expose-DyiZ5AU0.js");
+				const { cmdExpose } = await import("./expose-Bfo-dZdy.js");
 				return cmdExpose(rest);
 			}
 			case "callback": {
-				const { cmdCallback } = await import("./callback-Bgehh-IW.js");
+				const { cmdCallback } = await import("./callback-BnUbjH7p.js");
 				return cmdCallback(rest);
 			}
 			case "reap":
@@ -1428,7 +1457,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-Bl8eowma.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-D68dkqFp.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -2886,16 +2915,18 @@ async function cmdSend(rest) {
 	const canConfirm = trailing === "\r" && Boolean(fullBody) && !noWait;
 	let confirmed = true;
 	let lastScreen = [];
-	if (fullBody && trailing) {
-		await writeToIpc(fifoPath, fullBody);
-		if (canConfirm && record.log_file) {
-			await waitForLogQuiet(record.log_file, SEND_SETTLE_QUIET_MS, SEND_SETTLE_MAX_MS);
-			({confirmed, screen: lastScreen} = await submitAndConfirm(record, fifoPath, trailing));
-		} else {
-			await new Promise((r) => setTimeout(r, 200));
-			await writeToIpc(fifoPath, trailing);
-		}
-	} else await writeToIpc(fifoPath, fullBody + trailing);
+	await withIpcLock(record.pid, async () => {
+		if (fullBody && trailing) {
+			await writeToIpc(fifoPath, fullBody);
+			if (canConfirm && record.log_file) {
+				await waitForLogQuiet(record.log_file, SEND_SETTLE_QUIET_MS, SEND_SETTLE_MAX_MS);
+				({confirmed, screen: lastScreen} = await submitAndConfirm(record, fifoPath, trailing));
+			} else {
+				await new Promise((r) => setTimeout(r, 200));
+				await writeToIpc(fifoPath, trailing);
+			}
+		} else await writeToIpc(fifoPath, fullBody + trailing);
+	}, (why) => process.stderr.write(`warning: ay send writing pid ${record.pid} without the input lock (${why})\n`));
 	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`);
@@ -3098,7 +3129,7 @@ async function cmdKey(rest) {
 		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	});
 	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));
+	await withIpcLock(record.pid, () => writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace)), (why) => process.stderr.write(`warning: ay key/select writing pid ${record.pid} without the input lock (${why})\n`));
 	process.stdout.write(`sent to pid ${record.pid} (${record.cli}): ${keyNames.join(" ")}\n`);
 	await recordKeyEvent(sender, record, "key", keyNames.join(" "));
 	return 0;
@@ -3148,7 +3179,7 @@ async function cmdSelect(rest) {
 	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(", ")}.`);
 	const byteSeqs = menuSelectKeys(menu.cursor, n).map((k) => controlCodeFromName(k));
-	await writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace));
+	await withIpcLock(record.pid, () => writeKeysPaced(record.fifo_file, byteSeqs, Math.max(0, argv.pace)), (why) => process.stderr.write(`warning: ay key/select writing pid ${record.pid} without the input lock (${why})\n`));
 	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`);
@@ -3311,15 +3342,17 @@ async function cmdStop(rest) {
 		strategy = `double Ctrl+C (no known /exit for cli "${record.cli}")`;
 	} else throw new Error(`unknown --method=${method}`);
 	const fifoPath = record.fifo_file;
-	if (payload === "double-ctrl-c") {
-		await writeToIpc(fifoPath, "");
-		await new Promise((r) => setTimeout(r, 200));
-		await writeToIpc(fifoPath, "");
-	} else {
-		await writeToIpc(fifoPath, payload);
-		await new Promise((r) => setTimeout(r, 200));
-		await writeToIpc(fifoPath, "\r");
-	}
+	await withIpcLock(record.pid, async () => {
+		if (payload === "double-ctrl-c") {
+			await writeToIpc(fifoPath, "");
+			await new Promise((r) => setTimeout(r, 200));
+			await writeToIpc(fifoPath, "");
+		} else {
+			await writeToIpc(fifoPath, payload);
+			await new Promise((r) => setTimeout(r, 200));
+			await writeToIpc(fifoPath, "\r");
+		}
+	}, (why) => process.stderr.write(`warning: ay stop writing pid ${record.pid} without the input lock (${why})\n`));
 	process.stdout.write(`stopping pid ${record.pid} (${record.cli}) via ${strategy}\n`);
 	process.stderr.write(`\n  ay status ${record.pid}                # confirm it exited\n  ay ls --all                            # see exit codes\n`);
 	return 0;
@@ -3349,16 +3382,18 @@ async function gracefulExitAgent(record, reason) {
 	await writeNote(record.pid, `↩ exit — ${reason}`).catch(() => {});
 	const fifoPath = record.fifo_file;
 	const graceful = GRACEFUL_EXIT_COMMANDS[record.cli];
-	if (graceful) {
-		await writeToIpc(fifoPath, graceful);
+	return withIpcLock(record.pid, async () => {
+		if (graceful) {
+			await writeToIpc(fifoPath, graceful);
+			await new Promise((r) => setTimeout(r, 200));
+			await writeToIpc(fifoPath, "\r");
+			return { strategy: `'${graceful}' + Enter` };
+		}
+		await writeToIpc(fifoPath, "");
 		await new Promise((r) => setTimeout(r, 200));
-		await writeToIpc(fifoPath, "\r");
-		return { strategy: `'${graceful}' + Enter` };
-	}
-	await writeToIpc(fifoPath, "");
-	await new Promise((r) => setTimeout(r, 200));
-	await writeToIpc(fifoPath, "");
-	return { strategy: `double Ctrl+C (no known /exit for cli "${record.cli}")` };
+		await writeToIpc(fifoPath, "");
+		return { strategy: `double Ctrl+C (no known /exit for cli "${record.cli}")` };
+	}, (why) => process.stderr.write(`warning: ay exit writing pid ${record.pid} without the input lock (${why})\n`));
 }
 async function cmdExit(rest) {
 	const argv = await yargs(rest).usage("Usage: ay exit <keyword> [reason]").option("all", {
@@ -3465,7 +3500,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-BqRNIxeq.js");
+	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-BaHCO0bU.js");
 	const daemonBase = await resolveDaemonHttpBase().catch(() => null);
 	const daemonToken = daemonBase ? await loadTokenReadOnly().catch(() => null) ?? "" : "";
 	const capViewer = `attach:${process.pid}`;
@@ -4175,7 +4210,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-TKtSYtEO.js");
+		const { ensureDaemon } = await import("./notifyDaemon-Cf4KHDOr.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4249,7 +4284,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-TKtSYtEO.js");
+	const daemon = await import("./notifyDaemon-Cf4KHDOr.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4275,5 +4310,5 @@ async function cmdNotifyd(rest) {
 }
 
 //#endregion
-export { buildAgentForest as $, 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, flattenForest as et, 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-DJpVXIb6.js.map
+export { TYPING_BADGE as $, 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, withIpcLock 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, buildAgentForest as et, 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, flattenForest as tt, cursorAbs as u, isAgentStuck as v, isUnknownManagerToken as w, isPidAlive as x, isBareManagerInvocation as y, renderRawLogLines as z };
+//# sourceMappingURL=subcommands-03ghe-aZ.js.map

package/dist/{subcommands-DLrJfG4D.js → subcommands-BS4lnTrb.js}

@@ -1,11 +1,11 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
-import "./e2e-CUMZC53I.js";
-import "./configShared-DtHMBCl7.js";
-import { A as menuSelectKeys, B as resolveOne, C as isSubcommand, D as lastStdinAt, E as lastReadAt, F as recentMessageEdges, G as snapshotStatus, H as resolveResumeArgs, I as recentReadEdges, J as submitAndConfirm, K as stdinActivityPath, L as renderLogTailLines, M as readLogForRender, N as readNotes, O as listRecords, P as readPtysize, R as renderRawLog, S as isSlashCommand, T as isUserTyping, U as restartHintLines, V as resolveReadWindow, W as runSubcommand, X as writeKeysPaced, Y as waitForLogQuiet, Z as writeToIpc, _ as finalizedLines, a as TYPING_WINDOW_MS, b as isExitRequest, c as cmdHelp, d as deriveLiveState, f as deriveLiveStatus, g as extractTaskCounts, h as extractNeedsInput, i as READ_WINDOW_MS, j as readAgentPtysize, k as matchKeyword, l as controlCodeFromName, m as extractMenu, n as MAX_RENDER_BYTES, o as backoffWhileTyping, p as extractBadges, q as stopTipForCli, r as READ_PAGE_DEFAULT, s as cmdDeepseek, t as GRACEFUL_EXIT_COMMANDS, u as cursorAbs, v as isAgentStuck, w as isUnknownManagerToken, x as isPidAlive, y as isBareManagerInvocation, z as renderRawLogLines } from "./subcommands-DJpVXIb6.js";
-import "./notifyStore-Cbw2ZJ0X.js";
-import "./webrtcLink-DyCj380i.js";
-import "./remotes-DdAfueOu.js";
+import "./e2e-OLfcNxiv.js";
+import "./configShared-DYxlvrH0.js";
+import { A as menuSelectKeys, B as resolveOne, C as isSubcommand, D as lastStdinAt, E as lastReadAt, F as recentMessageEdges, G as snapshotStatus, H as resolveResumeArgs, I as recentReadEdges, J as submitAndConfirm, K as stdinActivityPath, L as renderLogTailLines, M as readLogForRender, N as readNotes, O as listRecords, P as readPtysize, R as renderRawLog, S as isSlashCommand, T as isUserTyping, U as restartHintLines, V as resolveReadWindow, W as runSubcommand, X as writeKeysPaced, Y as waitForLogQuiet, Z as writeToIpc, _ as finalizedLines, a as TYPING_WINDOW_MS, b as isExitRequest, c as cmdHelp, d as deriveLiveState, f as deriveLiveStatus, g as extractTaskCounts, h as extractNeedsInput, i as READ_WINDOW_MS, j as readAgentPtysize, k as matchKeyword, l as controlCodeFromName, m as extractMenu, n as MAX_RENDER_BYTES, o as backoffWhileTyping, p as extractBadges, q as stopTipForCli, r as READ_PAGE_DEFAULT, s as cmdDeepseek, t as GRACEFUL_EXIT_COMMANDS, u as cursorAbs, v as isAgentStuck, w as isUnknownManagerToken, x as isPidAlive, y as isBareManagerInvocation, z as renderRawLogLines } from "./subcommands-03ghe-aZ.js";
+import "./notifyStore-Dus2D1XA.js";
+import "./webrtcLink-B72AQ2eb.js";
+import "./remotes-IzQHupeo.js";
 
 export { READ_WINDOW_MS, cmdHelp, isBareManagerInvocation, isSubcommand, isUnknownManagerToken, lastReadAt, runSubcommand };

package/dist/{systemPathLink-BHv1I6wh.js → systemPathLink-DGVcx0fg.js}

@@ -88,4 +88,4 @@ function linkBunBinsToSystemPath(opts) {
 
 //#endregion
 export { linkBunBinsToSystemPath };
-//# sourceMappingURL=systemPathLink-BHv1I6wh.js.map
+//# sourceMappingURL=systemPathLink-DGVcx0fg.js.map

package/dist/{terminal-CRLPUaKF.js → terminal-DrCP-200.js}

@@ -98,7 +98,7 @@ async function cmdTermMint(args) {
 	if (flags.ro && flags.interactive) throw new Error("--ro and --interactive are mutually exclusive");
 	const ttlSec = parseTtlSec(typeof flags.ttl === "string" ? flags.ttl : "15m");
 	const canSend = flags.interactive === true;
-	const { mintScopedTermToken } = await import("./serve-BqRNIxeq.js");
+	const { mintScopedTermToken } = await import("./serve-BaHCO0bU.js");
 	const r = await mintScopedTermToken(pid, {
 		ttlSec,
 		canSend
@@ -135,4 +135,4 @@ async function cmdTerm(args) {
 
 //#endregion
 export { cmdTerm };
-//# sourceMappingURL=terminal-CRLPUaKF.js.map
+//# sourceMappingURL=terminal-DrCP-200.js.map

package/dist/terminal.js

@@ -1,3 +1,3 @@
-import { t as AyTerminal } from "./browser-DSduVZeZ.js";
+import { t as AyTerminal } from "./browser-CorYp8Yu.js";
 
 export { AyTerminal, AyTerminal as default };