claude-yes 1.170.1 → 1.172.0

package/dist/{SUPPORTED_CLIS-Bz-oXKG8.js → SUPPORTED_CLIS-KMkjT-Ny.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-kJRKPdFi.js";
+import { t as CLIS_CONFIG } from "./ts-DiMpa4ri.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-Bz-oXKG8.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-KMkjT-Ny.js.map

package/dist/SUPPORTED_CLIS-oB5KxI57.js

@@ -0,0 +1,8 @@
+import "./ts-DiMpa4ri.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-D6Qc6O3F.js";
+import "./pidStore-BIvsBQ8X.js";
+import "./globalPidIndex-CoNr7tS8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-KMkjT-Ny.js";
+
+export { SUPPORTED_CLIS };

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-eVbxzEL3.js";
-import { n as getRustBinary } from "./rustBinary-CYS7148m.js";
+import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-D6Qc6O3F.js";
+import { n as getRustBinary } from "./rustBinary-Bne6M0ik.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
@@ -285,7 +285,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DOnqoHyP.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DZtrr8ps.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		await cmdHelp(managerCommands);
 		process.exit(0);
@@ -327,7 +327,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-Dby-8X2S.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-oB5KxI57.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-kJRKPdFi.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DiMpa4ri.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-eVbxzEL3.js";
+import "./versionChecker-D6Qc6O3F.js";
 import "./pidStore-BIvsBQ8X.js";
 import "./globalPidIndex-CoNr7tS8.js";
 

package/dist/{notifyDaemon-BB08sE7n.js → notifyDaemon-tmytSfnS.js}

@@ -1,7 +1,7 @@
 import { n as logger } from "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./configShared-0MnIQ652.js";
-import { D as renderLogTailLines, G as hostId, J as readInbox, K as listInboxParents, Q as notifyDir, S as listRecords, U as appendEvent, W as gcInboxes, X as daemonLockDir, Y as shouldStealLock, Z as daemonLockOwnerPath, _ as isPidAlive, c as deriveLiveState, q as liveWatchers } from "./subcommands-CbcBfInM.js";
+import { D as renderLogTailLines, G as hostId, J as readInbox, K as listInboxParents, Q as notifyDir, S as listRecords, U as appendEvent, W as gcInboxes, X as daemonLockDir, Y as shouldStealLock, Z as daemonLockOwnerPath, _ as isPidAlive, c as deriveLiveState, q as liveWatchers } from "./subcommands-ZjESAcio.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-CC-4GuJb.js";
@@ -588,4 +588,4 @@ async function ensureDaemon() {
 
 //#endregion
 export { daemonStatus, ensureDaemon, requestDaemonStop, runDaemon };
-//# sourceMappingURL=notifyDaemon-BB08sE7n.js.map
+//# sourceMappingURL=notifyDaemon-tmytSfnS.js.map

package/dist/{rustBinary-CYS7148m.js → rustBinary-Bne6M0ik.js}

@@ -1,4 +1,4 @@
-import { r as getInstalledPackage } from "./versionChecker-eVbxzEL3.js";
+import { r as getInstalledPackage } from "./versionChecker-D6Qc6O3F.js";
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
@@ -225,4 +225,4 @@ async function getRustBinary(options = {}) {
 
 //#endregion
 export { getRustBinary as n, findSpawnHiddenLauncher as t };
-//# sourceMappingURL=rustBinary-CYS7148m.js.map
+//# sourceMappingURL=rustBinary-Bne6M0ik.js.map

package/dist/{schedule-D4KvBh5w.js → schedule-BrpCaCuz.js}

@@ -1,9 +1,9 @@
-import "./ts-kJRKPdFi.js";
+import "./ts-DiMpa4ri.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-eVbxzEL3.js";
+import "./versionChecker-D6Qc6O3F.js";
 import "./pidStore-BIvsBQ8X.js";
 import "./globalPidIndex-CoNr7tS8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bz-oXKG8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-KMkjT-Ny.js";
 import { d as resolveSpawnCwd } from "./workspaceConfig-BgqK-31W.js";
 import { createHash } from "node:crypto";
 
@@ -141,4 +141,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-D4KvBh5w.js.map
+//# sourceMappingURL=schedule-BrpCaCuz.js.map

package/dist/{serve-BN0mUK9m.js → serve-DvO4pj5p.js}

@@ -1,13 +1,13 @@
-import "./ts-kJRKPdFi.js";
+import "./ts-DiMpa4ri.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-eVbxzEL3.js";
-import { t as findSpawnHiddenLauncher } from "./rustBinary-CYS7148m.js";
+import { r as getInstalledPackage } from "./versionChecker-D6Qc6O3F.js";
+import { t as findSpawnHiddenLauncher } from "./rustBinary-Bne6M0ik.js";
 import "./pidStore-BIvsBQ8X.js";
 import { a as updateGlobalPidStatus } from "./globalPidIndex-CoNr7tS8.js";
 import { t as pgidForWrapper } from "./reaper-CWF2_ATd.js";
 import "./configShared-0MnIQ652.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bz-oXKG8.js";
-import { A as resolveOne, E as readPtysize, F as snapshotStatus, H as TYPING_BADGE, O as renderRawLog, S as listRecords, T as readNotes, V as writeToIpc, b as isUserTyping, f as extractNeedsInput, l as deriveLiveStatus, o as controlCodeFromName, p as extractTaskCounts, u as extractBadges } from "./subcommands-CbcBfInM.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-KMkjT-Ny.js";
+import { A as resolveOne, E as readPtysize, F as snapshotStatus, H as TYPING_BADGE, O as renderRawLog, S as listRecords, T as readNotes, V as writeToIpc, b as isUserTyping, f as extractNeedsInput, l as deriveLiveStatus, o as controlCodeFromName, p as extractTaskCounts, u as extractBadges } from "./subcommands-ZjESAcio.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-CC-4GuJb.js";
@@ -845,13 +845,31 @@ Options:
 		if (!root) return null;
 		return ensureRepoWatch(root).val;
 	};
+	const meaningfulStdinAt = /* @__PURE__ */ new Map();
+	const anyDaemonWriteAt = /* @__PURE__ */ new Map();
+	const isTerminalReply = (s) => /^\x1b\[(\d+;\d+R|\?[\d;]*c|>[\d;]*c|\d*n)$/.test(s);
+	const noteStdinWrite = async (pid, fifo, meaningful) => {
+		const mt = await stat(fifo).then((s) => s.mtimeMs).catch(() => null);
+		if (mt == null) return;
+		anyDaemonWriteAt.set(pid, mt);
+		if (meaningful) meaningfulStdinAt.set(pid, mt);
+	};
+	const resolveLastStdinAt = async (r) => {
+		const meaningful = meaningfulStdinAt.get(r.pid) ?? null;
+		if (!r.fifo_file) return meaningful;
+		const mtime = await stat(r.fifo_file).then((s) => s.mtimeMs).catch(() => null);
+		if (mtime == null) return meaningful;
+		return mtime > (anyDaemonWriteAt.get(r.pid) ?? 0) ? mtime : meaningful;
+	};
 	const withMeta = async (r) => {
 		const status = await deriveLiveStatus(r);
 		const question = status !== "exited" && !r.unresponsive ? await logNeedsInput(r.log_file, r.cli) : null;
 		const lastActiveAt = r.log_file ? await stat(r.log_file).then((s) => s.mtimeMs).catch(() => r.started_at) : r.started_at;
+		const lastStdinAt = status !== "exited" ? await resolveLastStdinAt(r) : null;
 		return {
 			...r,
 			last_active_at: lastActiveAt,
+			last_stdin_at: lastStdinAt,
 			status: status === "exited" ? status : r.unresponsive ? "stuck" : question ? "needs_input" : status,
 			question,
 			title: await logTitle(r.log_file),
@@ -1115,6 +1133,7 @@ Options:
 					await new Promise((r) => setTimeout(r, 200));
 					await writeToIpc(record.fifo_file, trailing);
 				} else await writeToIpc(record.fifo_file, msg + trailing);
+				await noteStdinWrite(record.pid, record.fifo_file, !isTerminalReply(msg));
 				return Response.json({
 					ok: true,
 					pid: record.pid
@@ -1558,4 +1577,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-BN0mUK9m.js.map
+//# sourceMappingURL=serve-DvO4pj5p.js.map

package/dist/{setup-CUrjwXNE.js → setup-DB2gMtqk.js}

@@ -32,7 +32,7 @@ async function cmdSetup(rest) {
 	if (!existsSync(abs)) process.stderr.write(`  note: that directory doesn't exist yet — create it, or agents spawned there will fail\n`);
 	if (noShare) return 0;
 	process.stdout.write(`\nsharing this machine to agent-yes.com…\n`);
-	const { cmdServe } = await import("./serve-BN0mUK9m.js");
+	const { cmdServe } = await import("./serve-DvO4pj5p.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-CUrjwXNE.js.map
+//# sourceMappingURL=setup-DB2gMtqk.js.map

package/dist/{subcommands-DOnqoHyP.js → subcommands-DZtrr8ps.js}

@@ -1,7 +1,7 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-CoNr7tS8.js";
 import "./configShared-0MnIQ652.js";
-import { A as resolveOne, B as writeKeysPaced, C as matchKeyword, D as renderLogTailLines, E as readPtysize, F as snapshotStatus, I as stdinActivityPath, L as stopTipForCli, M as resolveResumeArgs, N as restartHintLines, O as renderRawLog, P as runSubcommand, R as submitAndConfirm, S as listRecords, T as readNotes, V as writeToIpc, _ as isPidAlive, a as cmdHelp, b as isUserTyping, c as deriveLiveState, d as extractMenu, f as extractNeedsInput, g as isExitRequest, h as isAgentStuck, i as backoffWhileTyping, j as resolveReadWindow, k as renderRawLogLines, l as deriveLiveStatus, m as finalizedLines, n as READ_PAGE_DEFAULT, o as controlCodeFromName, p as extractTaskCounts, r as TYPING_WINDOW_MS, s as cursorAbs, t as GRACEFUL_EXIT_COMMANDS, u as extractBadges, v as isSlashCommand, w as menuSelectKeys, x as lastStdinAt, y as isSubcommand, z as waitForLogQuiet } from "./subcommands-CbcBfInM.js";
+import { A as resolveOne, B as writeKeysPaced, C as matchKeyword, D as renderLogTailLines, E as readPtysize, F as snapshotStatus, I as stdinActivityPath, L as stopTipForCli, M as resolveResumeArgs, N as restartHintLines, O as renderRawLog, P as runSubcommand, R as submitAndConfirm, S as listRecords, T as readNotes, V as writeToIpc, _ as isPidAlive, a as cmdHelp, b as isUserTyping, c as deriveLiveState, d as extractMenu, f as extractNeedsInput, g as isExitRequest, h as isAgentStuck, i as backoffWhileTyping, j as resolveReadWindow, k as renderRawLogLines, l as deriveLiveStatus, m as finalizedLines, n as READ_PAGE_DEFAULT, o as controlCodeFromName, p as extractTaskCounts, r as TYPING_WINDOW_MS, s as cursorAbs, t as GRACEFUL_EXIT_COMMANDS, u as extractBadges, v as isSlashCommand, w as menuSelectKeys, x as lastStdinAt, y as isSubcommand, z as waitForLogQuiet } from "./subcommands-ZjESAcio.js";
 import "./e2e-jb0Hp43q.js";
 import "./webrtcLink-B7REGtK2.js";
 import "./remotes-CC-4GuJb.js";

package/dist/{subcommands-CbcBfInM.js → subcommands-ZjESAcio.js}

@@ -1126,15 +1126,15 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-BN0mUK9m.js");
+				const { cmdServe } = await import("./serve-DvO4pj5p.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-CUrjwXNE.js");
+				const { cmdSetup } = await import("./setup-DB2gMtqk.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-D4KvBh5w.js");
+				const { cmdSchedule } = await import("./schedule-BrpCaCuz.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -3963,7 +3963,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-BB08sE7n.js");
+		const { ensureDaemon } = await import("./notifyDaemon-tmytSfnS.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4037,7 +4037,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-BB08sE7n.js");
+	const daemon = await import("./notifyDaemon-tmytSfnS.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4064,4 +4064,4 @@ async function cmdNotifyd(rest) {
 
 //#endregion
 export { resolveOne as A, writeKeysPaced as B, matchKeyword as C, renderLogTailLines as D, readPtysize as E, snapshotStatus as F, hostId as G, TYPING_BADGE as H, stdinActivityPath as I, readInbox as J, listInboxParents as K, stopTipForCli as L, resolveResumeArgs as M, restartHintLines as N, renderRawLog as O, runSubcommand as P, notifyDir as Q, submitAndConfirm as R, listRecords as S, readNotes as T, appendEvent as U, writeToIpc 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, resolveReadWindow as j, renderRawLogLines 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, waitForLogQuiet as z };
-//# sourceMappingURL=subcommands-CbcBfInM.js.map
+//# sourceMappingURL=subcommands-ZjESAcio.js.map

package/dist/{ts-kJRKPdFi.js → ts-DiMpa4ri.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-eVbxzEL3.js";
+import { r as getInstalledPackage } from "./versionChecker-D6Qc6O3F.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-kJRKPdFi.js.map
+//# sourceMappingURL=ts-DiMpa4ri.js.map

package/dist/{versionChecker-eVbxzEL3.js → versionChecker-D6Qc6O3F.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "claude-yes";
-var version = "1.170.1";
+var version = "1.172.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-eVbxzEL3.js.map
+//# sourceMappingURL=versionChecker-D6Qc6O3F.js.map

package/lab/ui/console-logic.js

@@ -348,7 +348,7 @@ function agentForestNodes(list) {
 // flat entry list BEFORE layeredRows builds the room/peer/agent tree (which keeps
 // the given order for siblings and first-seen order for room/peer groups). So
 // sorting reorders roots and siblings without breaking the nesting.
-export const SORT_MODES = ["state", "active", "created", "identity"];
+export const SORT_MODES = ["state", "active", "stdin", "created", "identity"];
 
 // Attention-first state ranking: someone scanning the fleet wants the agents that
 // need them (needs_input) up top, then the wedged ones (stuck), then live work,
@@ -383,21 +383,26 @@ function lastActive(e) {
 
 // Return a NEW array sorted for display per `mode` (default "state"):
 //   - "state":    attention-first state, then git busyness, then newest.
-//   - "active":   most recently active first (last_active_at desc).
+//   - "active":   most recently active first (last_active_at, i.e. stdout, desc).
+//   - "stdin":    most recently FED first (last_stdin_at desc) — which agent was
+//                 just driven/typed-into/`ay send`-ed. Agents never fed sort last.
 //   - "created":  newest first (started_at desc).
 //   - "identity": user@host:owner/repo/branch (alphabetical).
 // Every comparator falls back to newest-first so order is total & deterministic.
 export function sortEntries(entries, mode = "state") {
   const byNewest = (a, b) => (b.started_at || 0) - (a.started_at || 0);
   const byActive = (a, b) => lastActive(b) - lastActive(a) || byNewest(a, b);
+  const byStdin = (a, b) => (b.last_stdin_at ?? 0) - (a.last_stdin_at ?? 0) || byNewest(a, b);
   const cmp =
     mode === "active"
       ? byActive
-      : mode === "created"
-        ? byNewest
-        : mode === "identity"
-          ? (a, b) => fullIdent(a).localeCompare(fullIdent(b)) || byNewest(a, b)
-          : (a, b) => stateRank(a) - stateRank(b) || gitWeight(b) - gitWeight(a) || byNewest(a, b);
+      : mode === "stdin"
+        ? byStdin
+        : mode === "created"
+          ? byNewest
+          : mode === "identity"
+            ? (a, b) => fullIdent(a).localeCompare(fullIdent(b)) || byNewest(a, b)
+            : (a, b) => stateRank(a) - stateRank(b) || gitWeight(b) - gitWeight(a) || byNewest(a, b);
   return entries.slice().sort(cmp);
 }
 
@@ -549,6 +554,52 @@ export function nextIndex(len, i, dir) {
 // coordinate math lives here so it's unit-testable without a browser.
 // ---------------------------------------------------------------------------
 
+// ---- collaborative presence: peer focus + stdin flash ----------------------
+// The left panel colour-codes who's on which agent: your own selection is blue
+// (the .sel bar), every OTHER human peer's focus is yellow (.peerfocus), and a
+// row pulses when its stdin was just written — independent of focus, since an
+// `ay send` feeds an agent no one is looking at. These pure helpers own the
+// bookkeeping so index.html only measures the DOM.
+
+// Detect agents whose stdin just advanced. `seen` maps _key -> the last
+// last_stdin_at we observed; given the current entries, return the _keys whose
+// last_stdin_at is NEWER than what we'd seen (someone typed / `ay send` pushed),
+// and fold the new values into `seen`. A key seen for the FIRST time never
+// flashes (else every agent would pulse on initial load) — only a later bump
+// does. Keys no longer present are pruned so `seen` can't grow without bound.
+export function advanceStdinFlashes(entries, seen) {
+  const fresh = [];
+  const alive = new Set();
+  for (const e of entries) {
+    const key = e._key;
+    if (!key) continue;
+    alive.add(key);
+    const at = e.last_stdin_at;
+    if (typeof at !== "number") continue;
+    const prev = seen.get(key);
+    if (prev !== undefined && at > prev) fresh.push(key);
+    if (prev === undefined || at > prev) seen.set(key, at);
+  }
+  for (const key of [...seen.keys()]) if (!alive.has(key)) seen.delete(key);
+  return fresh;
+}
+
+// Summarize fleet presence for the peers badge + per-row chips. `records` is one
+// entry per OTHER viewer currently watching an agent: { key, viewer } (key = the
+// composite _key of the agent they're on). Returns { total, byKey }: `total`
+// distinct viewers (the "N peers" badge), `byKey` a Map of _key -> how many
+// peers watch that agent (the yellow per-row chip + .peerfocus trigger).
+export function focusSummary(records) {
+  const viewers = new Set();
+  const byKey = new Map();
+  for (const r of records) {
+    if (!r || !r.key || !r.viewer) continue;
+    viewers.add(r.viewer);
+    byKey.set(r.key, (byKey.get(r.key) || 0) + 1);
+  }
+  return { total: viewers.size, byKey };
+}
+
 // Stable per-viewer hue (0..359) for colour-coding peers' selections.
 export function hashHue(s) {
   let h = 0;

package/lab/ui/index.html

@@ -37,6 +37,9 @@
         --purple: #bc8cff;
         --pink: #f778ba;
         --red: #f85149;
+        /* Peer-focus yellow: a human collaborator (not you) is on this agent.
+           Distinct from your own blue (--accent) and the idle-dot amber. */
+        --peer: #e3b341;
         --mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, monospace;
         /* Safe-area insets — non-zero only in a standalone PWA on a notched /
            gesture-bar device (else 0, so these are harmless on desktop). Consumed
@@ -70,6 +73,7 @@
           --purple: #8250df;
           --pink: #bf3989;
           --red: #cf222e;
+          --peer: #bf8700;
         }
       }
       * {
@@ -420,6 +424,21 @@
         font-size: 11.5px;
         margin-top: 8px;
       }
+      .metaleft {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+      }
+      /* Peers badge beside the agent counter — how many other humans are in the
+         fleet right now. Yellow ("here") when a peer shares the agent you have
+         open, muted otherwise. Hidden entirely when you're alone. */
+      .peers {
+        color: var(--muted);
+        cursor: default;
+      }
+      .peers.here {
+        color: var(--peer);
+      }
       .connbadge {
         cursor: pointer;
         user-select: none;
@@ -818,6 +837,39 @@
         background: var(--panel);
         box-shadow: inset 3px 0 0 var(--accent);
       }
+      /* A human peer (not you) is watching this agent: yellow, mirrored on the
+         RIGHT edge so it can coexist with your own blue selection bar on the
+         left — a row you BOTH have open shows blue-left + yellow-right. */
+      .row.peerfocus {
+        box-shadow: inset -3px 0 0 var(--peer);
+        background: color-mix(in srgb, var(--peer) 7%, transparent);
+      }
+      .row.sel.peerfocus {
+        background: var(--panel);
+        box-shadow: inset 3px 0 0 var(--accent), inset -3px 0 0 var(--peer);
+      }
+      /* stdin just landed here (someone typed, or `ay send` pushed a command) —
+         pulse the row regardless of who (if anyone) is focused on it. Runs while
+         the .stdinflash class is present; index.html removes it after the window. */
+      .row.stdinflash {
+        animation: stdinpulse 0.6s ease-in-out infinite;
+      }
+      @keyframes stdinpulse {
+        0%,
+        100% {
+          background-color: transparent;
+        }
+        50% {
+          background-color: color-mix(in srgb, var(--peer) 24%, transparent);
+        }
+      }
+      /* Per-row chip: how many peers are watching THIS agent (yellow, mono). */
+      .peerchip {
+        font-family: var(--mono);
+        font-size: 11px;
+        color: var(--peer);
+        flex: none;
+      }
       .r1 {
         display: flex;
         align-items: center;
@@ -1392,7 +1444,10 @@
             />
           </div>
           <div class="meta">
-            <span id="count"></span>
+            <span class="metaleft">
+              <span id="count"></span>
+              <span id="peers" class="peers" hidden></span>
+            </span>
             <span class="metaright">
               <button id="foldbtn" class="viewbtn" title="fold subagent trees">⊞ subs</button>
               <button id="sortbtn" class="viewbtn" title="cycle sort order">⇅ state</button>
@@ -1584,6 +1639,8 @@
         SORT_MODES,
         taskLabel,
         badgesFor,
+        advanceStdinFlashes,
+        focusSummary,
         hashHue,
         selFromBottom,
         parseSel,
@@ -1610,6 +1667,17 @@
 
       let entries = [];
       let sel = null; // selected agent's composite key (room#pid)
+      // Collaborative presence, fleet-wide: focusByKey maps an agent's _key ->
+      // how many OTHER human peers are watching it (yellow bars + per-row chip);
+      // peerTotal is the distinct-peer count for the header badge. stdinSeen +
+      // flashUntil drive the stdin pulse: stdinSeen remembers each agent's last
+      // last_stdin_at so we can spot a bump, flashUntil holds the deadline the
+      // row keeps pulsing to. See advanceStdinFlashes/focusSummary (console-logic).
+      let focusByKey = new Map();
+      let peerTotal = 0;
+      const stdinSeen = new Map();
+      const flashUntil = new Map();
+      const STDIN_FLASH_MS = 1200;
       let es = null; // live-tail subscription closer
       let term = null; // xterm.js Terminal rendering the raw PTY stream
       let fit = null;
@@ -2713,10 +2781,65 @@
         }
         renderPeerSelections();
       }
+      // Fleet-wide presence: unlike pollPresence (only the SELECTED agent's host,
+      // for the terminal overlay), this reads EVERY live source's blackboard so
+      // the left panel can colour any agent a peer is watching. Each viewer
+      // self-reports the pid it's on; we map that back to the source's composite
+      // _key. Best-effort — a source that 404s (older host) contributes nothing.
+      async function pollFleetPresence() {
+        const recs = [];
+        await Promise.all(
+          [...sources.values()].map(async (s) => {
+            if (!s.tx || !s.live) return;
+            let all;
+            try {
+              all = await s.tx.fetchJSON("/api/presence");
+            } catch {
+              return;
+            }
+            if (!Array.isArray(all)) return;
+            const keyOfPid = new Map((s.agents || []).map((e) => [String(e.pid), e._key]));
+            for (const v of all) {
+              if (!v || v.viewer === myViewerId) continue;
+              const key = keyOfPid.get(String(v.agent));
+              // Prefix the viewer id with its source so the same id on two hosts
+              // still counts as two distinct people in the fleet total.
+              if (key) recs.push({ key, viewer: s.id + ":" + v.viewer });
+            }
+          }),
+        );
+        const sum = focusSummary(recs);
+        focusByKey = sum.byKey;
+        peerTotal = sum.total;
+        paintPeersBadge();
+        renderList();
+      }
+      // "N peers" badge beside the agent counter. Yellow when a peer shares the
+      // agent you have open ("same agent"); its tooltip breaks the count down by
+      // agent so you can see who's where. Hidden when you're the only one here.
+      function paintPeersBadge() {
+        const el = $("peers");
+        if (!el) return;
+        if (!peerTotal) {
+          el.hidden = true;
+          el.removeAttribute("title");
+          return;
+        }
+        el.hidden = false;
+        el.textContent = `👤 ${peerTotal} peer${peerTotal === 1 ? "" : "s"}`;
+        el.classList.toggle("here", !!(sel && focusByKey.get(sel)));
+        const lines = [...focusByKey.entries()].map(([k, n]) => {
+          const e = entries.find((x) => x._key === k);
+          const name = e ? e.title || cliLabel(e) || ident(e) || `pid ${e.pid}` : k;
+          return `  ${n} on ${name}`;
+        });
+        el.title = "peers watching agents in this fleet:\n" + lines.join("\n");
+      }
       // 3s heartbeat (< the host's 12s TTL): refresh our presence + read others',
       // and follow the canonical grid size (resize+scale, never reflow) so all
       // viewers stay on one shared canvas and selections line up.
       setInterval(() => {
+        pollFleetPresence(); // fleet-wide peer focus (independent of what's selected)
         if (!sel) return;
         sendPresence();
         pollPresence();
@@ -2727,6 +2850,23 @@
             .then(followAgentSize)
             .catch(() => {});
       }, 3000);
+      // Fast pulse loop: drive the stdin flash on the STABLE list DOM (toggle a
+      // class, no re-render) so a pulse begins/ends promptly regardless of the
+      // list's own render cadence. Cheap — a no-op until something is flashing.
+      setInterval(() => {
+        if (!flashUntil.size) return;
+        const now = Date.now();
+        for (const [k, until] of [...flashUntil.entries()]) if (until <= now) flashUntil.delete(k);
+        const listEl = $("list");
+        if (!listEl) return;
+        for (const el of listEl.querySelectorAll(".row[data-key]")) {
+          const key = el.getAttribute("data-key");
+          // Mirror rowFlags: never pulse the agent you have open (you see its input
+          // live; also stops your own terminal's protocol replies blinking the row).
+          const on = key !== sel && (flashUntil.get(key) || 0) > now;
+          el.classList.toggle("stdinflash", on);
+        }
+      }, 200);
 
       // Peer-selection overlay. The coordinate math (parseSel / selSegments /
       // hashHue) lives in console-logic.js (unit-tested); here we just measure the
@@ -3311,6 +3451,26 @@
         return `<div class="ghead g-${r.kind}">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="gicon">${icon}</span><span class="glabel">${esc(r.label || "")}</span>${ctag}<span class="gkind">${r.kind}</span></div>`;
       }
 
+      // Extra row classes for collaborative presence: a yellow bar when a human
+      // peer is watching this agent, plus the stdin pulse while its input just
+      // advanced. Empty in the solo case, so a single-user list is unchanged.
+      // The pulse is suppressed on the agent YOU have open (e._key === sel): you
+      // already see its input land live in the terminal, so a flash there is
+      // redundant — and it's the only row your own terminal's protocol replies
+      // could ever nudge, so this also keeps a resize from blinking your own row.
+      function rowFlags(e) {
+        const peers = focusByKey.get(e._key) || 0;
+        const flash = e._key !== sel && (flashUntil.get(e._key) || 0) > Date.now();
+        return (peers ? " peerfocus" : "") + (flash ? " stdinflash" : "");
+      }
+      // A yellow chip showing how many peers are watching this agent ("" if none).
+      function peerChipHtml(e) {
+        const n = focusByKey.get(e._key) || 0;
+        return n
+          ? `<span class="peerchip" title="${n} peer${n === 1 ? "" : "s"} watching this agent">👤${n}</span>`
+          : "";
+      }
+
       function renderList() {
         const toks = $("q").value.trim().split(/\s+/).filter(Boolean);
         // Build the full signalling-server > rooms > peers > agents > subagents
@@ -3325,6 +3485,7 @@
           ? fullRows.filter((r) => !(r.kind === "agent" && r.parentEntry))
           : fullRows;
         $("count").textContent = `${agentRows.length} / ${entries.length} agents`;
+        paintPeersBadge(); // keep the peers badge in step with sel / the entry list
         $("foldbtn").textContent = foldSubs ? "⊞ subs" : "⊟ subs";
         $("foldbtn").classList.toggle("on", !foldSubs);
         $("viewbtn").classList.toggle("on", compactList);
@@ -3347,7 +3508,7 @@
                 const t = e.title || e.prompt || "";
                 const id = compactIdent(e, ctx, 3, r.parentEntry);
                 const cli = cliLabel(e);
-                return `<div class="row crow ${e._key === sel ? "sel" : ""}" data-key="${esc(e._key)}">
+                return `<div class="row crow ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">
         ${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}
         <span class="dot ${esc(e.status)}"></span>
         ${hasIdent(id) ? `<span class="cident" title="${esc(fullIdent(e))}">${esc(id)}</span>` : ""}
@@ -3357,6 +3518,7 @@
         ${taskChipHtml(e)}
         ${badgeChipsHtml(e)}
         ${gitChipHtml(e)}
+        ${peerChipHtml(e)}
         <span class="age">${age(e)}</span></div>`;
               })
               .join("") || `<div class="empty">no match</div>`;
@@ -3376,7 +3538,7 @@
                     `<span class="rtag" data-k="${k}"><span style="opacity:.55">${k}:</span>${esc(v)}</span>`,
                 )
                 .join("");
-              return `<div class="row ${e._key === sel ? "sel" : ""}" data-key="${esc(e._key)}">
+              return `<div class="row ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">
         <div class="r1">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="dot ${esc(e.status)}"></span>
           <span class="name">${esc(cliLabel(e) || ident(e) || "agent")}</span>
           <span class="badge">pid ${e.pid}</span>
@@ -3384,6 +3546,7 @@
           ${taskChipHtml(e)}
           ${badgeChipsHtml(e)}
           ${gitChipHtml(e)}
+          ${peerChipHtml(e)}
           <span class="age">${age(e)}</span></div>
         ${e.title ? `<div class="rowtitle" title="${esc(e.title)}">${esc(e.title)}</div>` : ""}
         ${
@@ -3445,6 +3608,13 @@
       function mergeRender() {
         const srcs = [...sources.values()];
         entries = srcs.flatMap((s) => s.agents || []);
+        // Spot agents whose stdin just advanced (last_stdin_at bumped since we
+        // last saw them — someone typed, or `ay send` pushed input) and arm the
+        // pulse. Runs before renderList so the flashing rows render pulsing; the
+        // fast loop above stops them when the window lapses. Streamed deltas carry
+        // the new mtime, so a silent `ay send` still trips the flash within ~1s.
+        const until = Date.now() + STDIN_FLASH_MS;
+        for (const k of advanceStdinFlashes(entries, stdinSeen)) flashUntil.set(k, until);
         // Badge: total agents + how many rooms are live. Red only when nothing
         // at all is reachable (no source answered).
         const roomSrcs = srcs.filter((s) => s.id !== LOCAL);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.170.1",
+  "version": "1.172.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/serve.ts

@@ -1232,6 +1232,47 @@ export async function cmdServe(rest: string[]): Promise<number> {
     return ensureRepoWatch(root).val; // cached — the request path never spawns `git status`
   };
 
+  // Denoised "last meaningful stdin" tracking — drives the console's stdin flash
+  // and the `stdin` sort order. The FIFO's mtime alone is too noisy: xterm forwards
+  // the agent TUI's terminal-protocol auto-replies (cursor-position / device-
+  // attributes reports) to stdin, so a mere resize/redraw would bump it and the row
+  // would false-flash. So we stamp what WE write, split two ways: `meaningfulStdinAt`
+  // skips those auto-replies; `anyDaemonWriteAt` records every write we make. A FIFO
+  // mtime NEWER than any write we made can only be a local `ay send` (which writes
+  // the FIFO directly, bypassing us) — always meaningful — so it still counts. See
+  // resolveLastStdinAt below and the /api/send handler that stamps these.
+  const meaningfulStdinAt = new Map<number, number>();
+  const anyDaemonWriteAt = new Map<number, number>();
+  // A payload that is PURELY a terminal auto-reply (Cursor Position Report, Device
+  // Attributes, Device Status Report) — protocol chatter a TUI emits on redraw/resize,
+  // not a keystroke. Anchored so a chunk that also carries real input never matches;
+  // real typing (incl. arrow keys like `ESC[A`) never looks like one of these.
+  const isTerminalReply = (s: string) => /^\x1b\[(\d+;\d+R|\?[\d;]*c|>[\d;]*c|\d*n)$/.test(s);
+  // Stamp both maps after a daemon FIFO write, keyed off the FIFO's post-write mtime
+  // (so `anyDaemonWriteAt` is exactly our write's mtime — an external write bumps it
+  // strictly higher, which is how resolveLastStdinAt tells them apart with no clock skew).
+  const noteStdinWrite = async (pid: number, fifo: string, meaningful: boolean) => {
+    const mt = await stat(fifo)
+      .then((s) => s.mtimeMs)
+      .catch(() => null);
+    if (mt == null) return;
+    anyDaemonWriteAt.set(pid, mt);
+    if (meaningful) meaningfulStdinAt.set(pid, mt);
+  };
+  // last_stdin_at for a record: newest of (a) the last meaningful write we made and
+  // (b) a FIFO write we did NOT make (a local `ay send`, always meaningful). A mtime
+  // at/below our last write means the newest write was ours → use the meaningful stamp
+  // (which excludes auto-replies); a strictly newer mtime is an external real write.
+  const resolveLastStdinAt = async (r: { pid: number; fifo_file?: string | null }) => {
+    const meaningful = meaningfulStdinAt.get(r.pid) ?? null;
+    if (!r.fifo_file) return meaningful;
+    const mtime = await stat(r.fifo_file)
+      .then((s) => s.mtimeMs)
+      .catch(() => null);
+    if (mtime == null) return meaningful;
+    return mtime > (anyDaemonWriteAt.get(r.pid) ?? 0) ? mtime : meaningful;
+  };
+
   // One agent record decorated for the console: the latest OSC title + a git
   // snapshot (skipped for exited agents — their repo state is no longer live).
   const withMeta = async (r: Awaited<ReturnType<typeof listRecords>>[number]) => {
@@ -1255,9 +1296,17 @@ export async function cmdServe(rest: string[]): Promise<number> {
           .then((s) => s.mtimeMs)
           .catch(() => r.started_at)
       : r.started_at;
+    // Last-stdin time: when this agent was last fed MEANINGFUL input — a real
+    // keystroke, the console composer, or an `ay send` (local or remote) — but NOT
+    // the TUI's terminal-protocol auto-replies, which would otherwise make a resize
+    // or redraw look like input. The console flashes a row when this advances (so a
+    // collaborator sees input land even when they weren't the one sending it) and can
+    // sort by it. See resolveLastStdinAt / noteStdinWrite. Null for exited agents.
+    const lastStdinAt = status !== "exited" ? await resolveLastStdinAt(r) : null;
     return {
       ...r,
       last_active_at: lastActiveAt,
+      last_stdin_at: lastStdinAt,
       // Precedence: exited stays exited; the Rust supervisor's unresponsive flag is
       // an authoritative wedge signal (`stuck`); then a blocked menu (`needs_input`);
       // else the base live status — so the console's dot matches `ay ls`. (A dead
@@ -1653,6 +1702,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
         } else {
           await writeToIpc(record.fifo_file, msg + trailing);
         }
+        // Record this write for the stdin flash / sort. A payload that is purely a
+        // terminal auto-reply (xterm answering the TUI's cursor/DA query, forwarded
+        // over this same wire) is protocol noise, not input — stamp anyDaemonWriteAt
+        // but not the "meaningful" time, so a resize/redraw can't trip the flash.
+        await noteStdinWrite(record.pid, record.fifo_file, !isTerminalReply(msg));
         return Response.json({ ok: true, pid: record.pid });
       } catch (e) {
         return new Response((e as Error).message, { status: 404 });

package/dist/SUPPORTED_CLIS-Dby-8X2S.js

@@ -1,8 +0,0 @@
-import "./ts-kJRKPdFi.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-eVbxzEL3.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bz-oXKG8.js";
-
-export { SUPPORTED_CLIS };