agent-yes 1.112.1 → 1.114.0

package/dist/{SUPPORTED_CLIS-DxYk0BWq.js → SUPPORTED_CLIS--15XPtGd.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-gFuntNxO.js";
+import { t as CLIS_CONFIG } from "./ts-CZQs_t8w.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-DxYk0BWq.js.map
+//# sourceMappingURL=SUPPORTED_CLIS--15XPtGd.js.map

package/dist/SUPPORTED_CLIS-DE31jVYi.js

@@ -0,0 +1,8 @@
+import "./ts-CZQs_t8w.js";
+import "./logger-B9h0djqx.js";
+import "./versionChecker-C1W2s4ZP.js";
+import "./pidStore-DBjlqzo8.js";
+import "./globalPidIndex-yVd3mbsV.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS--15XPtGd.js";
+
+export { SUPPORTED_CLIS };

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { n as logger } from "./logger-B9h0djqx.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-DlY0TAHI.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-C1W2s4ZP.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -482,7 +482,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 {
 	const rawArg = process.argv[2];
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-BdLzSIjI.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-8hMGFqkQ.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp();
 		process.exit(0);
@@ -515,7 +515,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-OeK9JJli.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DE31jVYi.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-gFuntNxO.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-CZQs_t8w.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-DlY0TAHI.js";
+import "./versionChecker-C1W2s4ZP.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
 

package/dist/{serve-B6jO9ifl.js → serve-DEDkRdog.js}

@@ -1,11 +1,11 @@
-import "./ts-gFuntNxO.js";
+import "./ts-CZQs_t8w.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-DlY0TAHI.js";
+import "./versionChecker-C1W2s4ZP.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DxYk0BWq.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS--15XPtGd.js";
 import "./remotes-C3xPRtfg.js";
-import { c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, m as snapshotStatus, r as controlCodeFromName, u as readNotes } from "./subcommands-CCV37_dc.js";
+import { c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, m as snapshotStatus, r as controlCodeFromName, u as readNotes } from "./subcommands-Di_pcW0_.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -220,6 +220,58 @@ Options:
 			return null;
 		}
 	};
+	const GIT_TTL_MS = 5e3;
+	const gitCache = /* @__PURE__ */ new Map();
+	const gitStatus = async (cwd) => {
+		if (!cwd) return null;
+		const now = Date.now();
+		const hit = gitCache.get(cwd);
+		if (hit && now - hit.at < GIT_TTL_MS) return hit.val;
+		let val = null;
+		try {
+			const proc = Bun.spawn([
+				"git",
+				"status",
+				"--porcelain",
+				"--branch"
+			], {
+				cwd,
+				stdout: "pipe",
+				stderr: "ignore",
+				signal: AbortSignal.timeout(2e3)
+			});
+			const out = await new Response(proc.stdout).text();
+			await proc.exited;
+			if (proc.exitCode === 0) {
+				const lines = out.split("\n");
+				const h = /^## (.+)$/.exec(lines[0] ?? "")?.[1] ?? "";
+				const unborn = /^No commits yet on (.+)$/.exec(h);
+				const branch = unborn ? unborn[1] : /^(.+?)(?:\.\.\.|\s|$)/.exec(h)?.[1] || null;
+				const ahead = Number(/\bahead (\d+)/.exec(h)?.[1] ?? 0);
+				const behind = Number(/\bbehind (\d+)/.exec(h)?.[1] ?? 0);
+				const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
+				val = {
+					branch,
+					dirty: changed > 0,
+					changed,
+					ahead,
+					behind
+				};
+			}
+		} catch {
+			val = null;
+		}
+		gitCache.set(cwd, {
+			at: now,
+			val
+		});
+		return val;
+	};
+	const withMeta = async (r) => ({
+		...r,
+		title: await logTitle(r.log_file),
+		git: r.status === "exited" ? null : await gitStatus(r.cwd)
+	});
 	const apiFetch = async (req) => {
 		if (!checkAuth(req, token)) return new Response("Unauthorized", { status: 401 });
 		const url = new URL(req.url);
@@ -232,15 +284,81 @@ Options:
 			});
 			try {
 				const records = await listRecords(keyword, opts);
-				const withTitles = await Promise.all(records.map(async (r) => ({
-					...r,
-					title: await logTitle(r.log_file)
-				})));
-				return Response.json(withTitles);
+				return Response.json(await Promise.all(records.map(withMeta)));
 			} catch (e) {
 				return new Response(e.message, { status: 500 });
 			}
 		}
+		if (req.method === "GET" && p === "/api/ls/subscribe") {
+			const keyword = url.searchParams.get("keyword") ?? void 0;
+			const opts = defaultOpts({
+				all: url.searchParams.get("all") === "1",
+				active: url.searchParams.get("active") === "1"
+			});
+			const enc = new TextEncoder();
+			const stream = new ReadableStream({ async start(ctrl) {
+				let closed = false;
+				const send = (obj) => {
+					try {
+						ctrl.enqueue(enc.encode(`data: ${JSON.stringify(obj)}\n\n`));
+					} catch {}
+				};
+				const sent = /* @__PURE__ */ new Map();
+				const compute = async () => {
+					const records = await listRecords(keyword, opts);
+					return Promise.all(records.map(withMeta));
+				};
+				const tick = async (first) => {
+					if (closed) return;
+					const list = await compute().catch(() => null);
+					if (!list) return;
+					const upsert = [];
+					const seen = /* @__PURE__ */ new Set();
+					for (const r of list) {
+						seen.add(r.pid);
+						const j = JSON.stringify(r);
+						if (sent.get(r.pid) !== j) {
+							upsert.push(r);
+							sent.set(r.pid, j);
+						}
+					}
+					const remove = [];
+					for (const pid of sent.keys()) if (!seen.has(pid)) {
+						remove.push(pid);
+						sent.delete(pid);
+					}
+					if (first) send({
+						full: true,
+						upsert: list,
+						remove: []
+					});
+					else if (upsert.length || remove.length) send({
+						upsert,
+						remove
+					});
+				};
+				await tick(true);
+				const timer = setInterval(() => void tick(false), 1e3);
+				const heartbeat = setInterval(() => {
+					try {
+						ctrl.enqueue(enc.encode(": ping\n\n"));
+					} catch {}
+				}, 15e3);
+				req.signal.addEventListener("abort", () => {
+					closed = true;
+					clearInterval(timer);
+					clearInterval(heartbeat);
+					try {
+						ctrl.close();
+					} catch {}
+				});
+			} });
+			return new Response(stream, { headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				Connection: "keep-alive"
+			} });
+		}
 		if (req.method === "GET" && p === "/api/whoami") {
 			let user = "";
 			try {
@@ -560,4 +678,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-B6jO9ifl.js.map
+//# sourceMappingURL=serve-DEDkRdog.js.map

package/dist/{subcommands-BdLzSIjI.js → subcommands-8hMGFqkQ.js}

@@ -1,6 +1,6 @@
 import "./logger-B9h0djqx.js";
 import "./globalPidIndex-yVd3mbsV.js";
 import "./remotes-C3xPRtfg.js";
-import { a as finalizedLines, c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, h as stopTipForCli, i as cursorAbs, l as matchKeyword, m as snapshotStatus, n as cmdHelp, o as isPidAlive, p as runSubcommand, r as controlCodeFromName, s as isSubcommand, t as GRACEFUL_EXIT_COMMANDS, u as readNotes } from "./subcommands-CCV37_dc.js";
+import { a as finalizedLines, c as listRecords, d as renderRawLog, f as resolveOne, g as writeToIpc, h as stopTipForCli, i as cursorAbs, l as matchKeyword, m as snapshotStatus, n as cmdHelp, o as isPidAlive, p as runSubcommand, r as controlCodeFromName, s as isSubcommand, t as GRACEFUL_EXIT_COMMANDS, u as readNotes } from "./subcommands-Di_pcW0_.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-CCV37_dc.js → subcommands-Di_pcW0_.js}

@@ -163,7 +163,7 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-B6jO9ifl.js");
+				const { cmdServe } = await import("./serve-DEDkRdog.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
@@ -1595,4 +1595,4 @@ async function cmdStatus(rest) {
 
 //#endregion
 export { finalizedLines as a, listRecords as c, renderRawLog as d, resolveOne as f, writeToIpc as g, stopTipForCli as h, cursorAbs as i, matchKeyword as l, snapshotStatus as m, cmdHelp as n, isPidAlive as o, runSubcommand as p, controlCodeFromName as r, isSubcommand as s, GRACEFUL_EXIT_COMMANDS as t, readNotes as u };
-//# sourceMappingURL=subcommands-CCV37_dc.js.map
+//# sourceMappingURL=subcommands-Di_pcW0_.js.map

package/dist/{ts-gFuntNxO.js → ts-CZQs_t8w.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-DlY0TAHI.js";
+import { r as getInstalledPackage } from "./versionChecker-C1W2s4ZP.js";
 import { n as agentYesHome, t as PidStore } from "./pidStore-DBjlqzo8.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CJxsoGdb.js";
 import { i as readGlobalPids } from "./globalPidIndex-yVd3mbsV.js";
@@ -1714,4 +1714,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-gFuntNxO.js.map
+//# sourceMappingURL=ts-CZQs_t8w.js.map

package/dist/{versionChecker-DlY0TAHI.js → versionChecker-C1W2s4ZP.js}

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

package/lab/ui/console-logic.js

@@ -115,6 +115,20 @@ export function tagsFor(e) {
   return t;
 }
 
+// Compact git indicator from the record's `git` snapshot (server-side
+// `git status --porcelain --branch`): "±3" changed files, "↑1" ahead, "↓2"
+// behind. Returns "" when there's no git info or the tree is clean and in sync,
+// so a tidy repo adds no noise. Branch itself is shown via the path identity.
+export function gitLabel(e) {
+  const g = e.git;
+  if (!g) return "";
+  const parts = [];
+  if (g.changed > 0) parts.push("±" + g.changed);
+  if (g.ahead > 0) parts.push("↑" + g.ahead);
+  if (g.behind > 0) parts.push("↓" + g.behind);
+  return parts.join(" ");
+}
+
 // Human age of an agent ("12s" / "5m" / "3h"). `now` is injectable so tests
 // don't depend on the wall clock; the browser calls age(e) and gets Date.now().
 export function age(e, now = Date.now()) {
@@ -130,7 +144,16 @@ export function age(e, now = Date.now()) {
 // case-insensitive substring search over title/prompt/cli/cwd/status.
 export function matches(e, toks) {
   const hay =
-    (e.title || "") + " " + (e.prompt || "") + " " + e.cli + " " + (e.cwd || "") + " " + e.status;
+    (e.title || "") +
+    " " +
+    (e.prompt || "") +
+    " " +
+    e.cli +
+    " " +
+    (e.cwd || "") +
+    " " +
+    e.status +
+    (e.git?.dirty ? " dirty" : "");
   return toks.every((tok) => {
     tok = tok.toLowerCase();
     const ci = tok.indexOf(":");

package/lab/ui/index.html

@@ -505,6 +505,17 @@
         color: var(--muted);
         font-size: 11.5px;
       }
+      /* git chip: ±changed ↑ahead ↓behind, amber when the worktree is dirty */
+      .git {
+        font-family: var(--mono);
+        font-size: 10.5px;
+        color: var(--muted);
+        white-space: nowrap;
+        flex: none;
+      }
+      .git.dirty {
+        color: var(--amber);
+      }
       .detail {
         color: var(--muted);
         font-size: 12.5px;
@@ -821,6 +832,7 @@
         repoBranch,
         ident,
         tagsFor,
+        gitLabel,
         age,
         matches,
         nextIndex,
@@ -1227,7 +1239,7 @@
         const hasToken = !!localStorage.getItem("ay.localToken");
         const enabled = isLocalhost || hasToken || Object.keys(loadRooms()).length === 0;
         if (enabled && !sources.has(LOCAL)) {
-          sources.set(LOCAL, {
+          const s = {
             id: LOCAL,
             host: "local",
             kind: "local",
@@ -1237,8 +1249,11 @@
             tried: true, // no connect phase — polled directly
             devices: new Set(),
             serverCount: 0,
-          });
-        } else if (!enabled) {
+          };
+          sources.set(LOCAL, s);
+          subscribeSource(s);
+        } else if (!enabled && sources.has(LOCAL)) {
+          unsubscribeSource(sources.get(LOCAL));
           sources.delete(LOCAL);
         }
       }
@@ -1246,33 +1261,100 @@
       // Pull one source's agent list, tagging each row with its origin + a
       // composite key (pids can collide across rooms). Updates the source's live
       // flag, device set, and server count for the rooms panel.
+      // Stamp a source's raw /api/ls records with their origin + composite key
+      // (pids collide across rooms) and recompute the source's device set + server
+      // count for the rooms panel. Pure transform of the source's current records.
+      function stampAgents(s) {
+        s.devices = new Set();
+        const out = [...(s.byPid?.values() || [])].map((e) => {
+          // codehost stamps _host per agent; agent-yes share rooms fall back to
+          // the room's device label (from /api/whoami). Local stays unlabelled
+          // (no deviceLabel) so a single-machine view keeps its clean path-only
+          // identity instead of a blank "@:" prefix.
+          const host = e._host || s.deviceLabel || "";
+          if (host) s.devices.add(host);
+          return { ...e, _room: s.id, _key: s.id + "#" + e.pid, _host: host };
+        });
+        s.serverCount =
+          s.kind === "ch" ? s.client?.hosts().length || 0 : s.devices.size || (s.live ? 1 : 0);
+        s.agents = out;
+      }
+
+      // Replace a source's whole record set (full /api/ls fetch or a stream
+      // snapshot). Resets byPid so later stream deltas diff against it cleanly.
+      function applyFull(s, arr) {
+        s.byPid = new Map((Array.isArray(arr) ? arr : []).map((r) => [r.pid, r]));
+        s.live = true;
+        stampAgents(s);
+      }
+
+      // Apply one stream event: a full snapshot, or an incremental
+      // { upsert:[changed], remove:[gone pids] } delta from /api/ls/subscribe.
+      function applyDelta(s, ev) {
+        if (ev.full) return applyFull(s, ev.upsert);
+        if (!s.byPid) s.byPid = new Map();
+        for (const r of ev.upsert || []) s.byPid.set(r.pid, r);
+        for (const pid of ev.remove || []) s.byPid.delete(pid);
+        s.live = true;
+        stampAgents(s);
+      }
+
+      // Fallback poll for a source that isn't streaming (older host with no
+      // /api/ls/subscribe, or before its first delta lands).
       async function listSource(s) {
         try {
-          const arr = await s.tx.fetchJSON("/api/ls?all=1");
-          s.live = true;
-          s.devices = new Set();
-          const out = (Array.isArray(arr) ? arr : []).map((e) => {
-            // codehost stamps _host per agent; agent-yes share rooms fall back to
-            // the room's device label (from /api/whoami). Local stays unlabelled
-            // (no deviceLabel) so a single-machine view keeps its clean path-only
-            // identity instead of a blank "@:" prefix.
-            const host = e._host || s.deviceLabel || "";
-            if (host) s.devices.add(host);
-            return { ...e, _room: s.id, _key: s.id + "#" + e.pid, _host: host };
-          });
-          s.serverCount =
-            s.kind === "ch" ? s.client?.hosts().length || 0 : s.devices.size || (s.live ? 1 : 0);
-          return out;
+          applyFull(s, await s.tx.fetchJSON("/api/ls?all=1"));
+          return s.agents;
         } catch {
           s.live = false;
           s.serverCount = 0;
+          s.byPid = new Map();
+          s.agents = [];
           return [];
         }
       }
 
+      // Subscribe to a source's throttled delta stream instead of re-polling its
+      // whole list. The first event flips `streaming` on, so the reconcile poll
+      // skips this source — no duplicate full-list bytes on the wire. Older hosts
+      // without the endpoint never send an event, so the poll keeps covering them.
+      function subscribeSource(s) {
+        if (!s.tx || s.unsub) return;
+        s.unsub = s.tx.subscribe(
+          "/api/ls/subscribe?all=1",
+          (ev) => {
+            if (!ev || typeof ev !== "object") return;
+            s.streaming = true;
+            applyDelta(s, ev);
+            mergeRender();
+          },
+          null,
+          () => {
+            s.streaming = false;
+          },
+        );
+      }
+      function unsubscribeSource(s) {
+        try {
+          s.unsub?.();
+        } catch {}
+        s.unsub = null;
+        s.streaming = false;
+      }
+
       // Compact list: one line per agent (dot + cli + title), persisted per device.
       let compactList = localStorage.getItem("ay.compactList") === "1";
 
+      // A small git chip (±changed ↑ahead ↓behind) for a row, amber when the tree
+      // is dirty. Empty for clean/in-sync repos and non-git cwds — no noise.
+      function gitChipHtml(e) {
+        const label = gitLabel(e);
+        if (!label) return "";
+        const g = e.git || {};
+        const tip = `git: ${g.changed || 0} changed · ${g.ahead || 0} ahead · ${g.behind || 0} behind`;
+        return `<span class="git${g.dirty ? " dirty" : ""}" title="${esc(tip)}">${esc(label)}</span>`;
+      }
+
       function renderList() {
         const toks = $("q").value.trim().split(/\s+/).filter(Boolean);
         const shown = entries.filter((e) => matches(e, toks));
@@ -1295,6 +1377,7 @@
         ${hasIdent(id) ? `<span class="cident" title="${esc(fullIdent(e))}">${esc(id)}</span>` : ""}
         ${cli ? `<span class="cname">${esc(cli)}</span>` : ""}
         <span class="ctitle ${e.title ? "" : "dim"}" title="${esc(t)}">${esc(t)}</span>
+        ${gitChipHtml(e)}
         <span class="age">${age(e)}</span></div>`;
               })
               .join("") || `<div class="empty">no match</div>`;
@@ -1316,6 +1399,7 @@
         <div class="r1"><span class="dot ${esc(e.status)}"></span>
           <span class="name">${esc(cliLabel(e) || ident(e) || "agent")}</span>
           <span class="badge">pid ${e.pid}</span>
+          ${gitChipHtml(e)}
           <span class="age">${age(e)}</span></div>
         ${e.title ? `<div class="rowtitle" title="${esc(e.title)}">${esc(e.title)}</div>` : ""}
         ${e.prompt ? `<div class="detail" title="${esc(e.prompt)}">${esc(e.prompt)}</div>` : ""}
@@ -1354,10 +1438,23 @@
       // composite key (room#pid) or a bare pid (?pid= deep links, legacy ay.sel).
       const matchSel = (e, token) => e._key === token || String(e.pid) === String(token);
 
+      // Reconcile poll: refresh only the sources that aren't streaming (older
+      // hosts, or ones whose stream hasn't delivered its first snapshot yet) and
+      // re-render. Streaming sources keep themselves current via subscribeSource,
+      // so this stays a no-op on the wire for a modern fleet — it still re-renders
+      // every tick, which keeps the relative "age" column fresh.
       async function loadList() {
         const srcs = [...sources.values()];
-        const lists = await Promise.all(srcs.map(listSource));
-        entries = lists.flat();
+        await Promise.all(srcs.filter((s) => !s.streaming).map(listSource));
+        mergeRender();
+      }
+
+      // Merge every source's stamped agents into the flat `entries` list, update
+      // the connection badge + rooms panel, and re-render. Called after every poll
+      // and every stream delta.
+      function mergeRender() {
+        const srcs = [...sources.values()];
+        entries = srcs.flatMap((s) => s.agents || []);
         // 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);
@@ -1636,6 +1733,7 @@
       function removeSource(room) {
         const s = sources.get(room);
         if (!s) return;
+        unsubscribeSource(s);
         try {
           s.client?.close?.();
           s.client?.pc?.close?.();
@@ -1703,6 +1801,7 @@
         }
         s.tried = true;
         renderRoomsIfOpen();
+        if (s.live) subscribeSource(s);
         loadList();
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.112.1",
+  "version": "1.114.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

@@ -291,6 +291,62 @@ export async function cmdServe(rest: string[]): Promise<number> {
     }
   };
 
+  // Per-cwd git snapshot for the list: branch + dirty/changed count + ahead/behind
+  // vs upstream, all from a single `git status --porcelain --branch`. Cached per
+  // cwd with a short TTL so the 1s subscribe tick (and /api/ls polls) spawn at most
+  // one git per repo every few seconds — agents sharing a cwd share the result.
+  // Non-git dirs, errors, and timeouts cache as null.
+  interface GitInfo {
+    branch: string | null;
+    dirty: boolean;
+    changed: number;
+    ahead: number;
+    behind: number;
+  }
+  const GIT_TTL_MS = 5000;
+  const gitCache = new Map<string, { at: number; val: GitInfo | null }>();
+  const gitStatus = async (cwd: string | null | undefined): Promise<GitInfo | null> => {
+    if (!cwd) return null;
+    const now = Date.now();
+    const hit = gitCache.get(cwd);
+    if (hit && now - hit.at < GIT_TTL_MS) return hit.val;
+    let val: GitInfo | null = null;
+    try {
+      const proc = Bun.spawn(["git", "status", "--porcelain", "--branch"], {
+        cwd,
+        stdout: "pipe",
+        stderr: "ignore",
+        signal: AbortSignal.timeout(2000),
+      });
+      const out = await new Response(proc.stdout).text();
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        const lines = out.split("\n");
+        // Branch header, e.g. "## main...origin/main [ahead 1, behind 2]",
+        // "## main" (no upstream), "## HEAD (no branch)", or "## No commits yet on x".
+        const h = /^## (.+)$/.exec(lines[0] ?? "")?.[1] ?? "";
+        const unborn = /^No commits yet on (.+)$/.exec(h);
+        const branch = unborn ? unborn[1]! : /^(.+?)(?:\.\.\.|\s|$)/.exec(h)?.[1] || null;
+        const ahead = Number(/\bahead (\d+)/.exec(h)?.[1] ?? 0);
+        const behind = Number(/\bbehind (\d+)/.exec(h)?.[1] ?? 0);
+        const changed = lines.slice(1).filter((l) => l.trim().length > 0).length;
+        val = { branch, dirty: changed > 0, changed, ahead, behind };
+      }
+    } catch {
+      val = null; // git missing, not a repo, or timed out
+    }
+    gitCache.set(cwd, { at: now, val });
+    return val;
+  };
+
+  // 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]) => ({
+    ...r,
+    title: await logTitle(r.log_file),
+    git: r.status === "exited" ? null : await gitStatus(r.cwd),
+  });
+
   // The whole API as a plain handler: served over HTTP by Bun.serve (--http)
   // and called in-process by the WebRTC bridge (--webrtc) — the latter needs
   // no TCP port at all.
@@ -311,15 +367,97 @@ export async function cmdServe(rest: string[]): Promise<number> {
       });
       try {
         const records = await listRecords(keyword, opts);
-        const withTitles = await Promise.all(
-          records.map(async (r) => ({ ...r, title: await logTitle(r.log_file) })),
-        );
-        return Response.json(withTitles);
+        return Response.json(await Promise.all(records.map(withMeta)));
       } catch (e) {
         return new Response((e as Error).message, { status: 500 });
       }
     }
 
+    // GET /api/ls/subscribe — SSE: throttled live deltas of the agent list.
+    // The console used to re-poll /api/ls every 3s; this streams the SAME records
+    // (incl. each agent's OSC title) but only what CHANGED since the last tick, so
+    // an idle fleet costs ~nothing on the wire. The first event is a full snapshot
+    // ({ full:true, upsert:[all] }); each later event carries { upsert:[changed
+    // records], remove:[gone pids] }. listRecords is a couple of JSONL reads and
+    // logTitle is cached by (size,mtime), so the 1s tick stays cheap.
+    if (req.method === "GET" && p === "/api/ls/subscribe") {
+      const keyword = url.searchParams.get("keyword") ?? undefined;
+      const opts = defaultOpts({
+        all: url.searchParams.get("all") === "1",
+        active: url.searchParams.get("active") === "1",
+      });
+      const enc = new TextEncoder();
+      const stream = new ReadableStream({
+        async start(ctrl) {
+          let closed = false;
+          const send = (obj: unknown) => {
+            try {
+              ctrl.enqueue(enc.encode(`data: ${JSON.stringify(obj)}\n\n`));
+            } catch {
+              /* stream already closed */
+            }
+          };
+          // pid -> JSON of the last record we sent, for cheap change detection.
+          const sent = new Map<number, string>();
+          const compute = async () => {
+            const records = await listRecords(keyword, opts);
+            return Promise.all(records.map(withMeta));
+          };
+          const tick = async (first: boolean) => {
+            if (closed) return;
+            // Transient read error → skip this tick, retry on the next.
+            const list = await compute().catch(() => null);
+            if (!list) return;
+            const upsert: typeof list = [];
+            const seen = new Set<number>();
+            for (const r of list) {
+              seen.add(r.pid);
+              const j = JSON.stringify(r);
+              if (sent.get(r.pid) !== j) {
+                upsert.push(r);
+                sent.set(r.pid, j);
+              }
+            }
+            const remove: number[] = [];
+            for (const pid of sent.keys())
+              if (!seen.has(pid)) {
+                remove.push(pid);
+                sent.delete(pid);
+              }
+            if (first) send({ full: true, upsert: list, remove: [] });
+            else if (upsert.length || remove.length) send({ upsert, remove });
+          };
+
+          await tick(true);
+          const timer = setInterval(() => void tick(false), 1000);
+          const heartbeat = setInterval(() => {
+            try {
+              ctrl.enqueue(enc.encode(": ping\n\n"));
+            } catch {
+              /* closed */
+            }
+          }, 15_000);
+          req.signal.addEventListener("abort", () => {
+            closed = true;
+            clearInterval(timer);
+            clearInterval(heartbeat);
+            try {
+              ctrl.close();
+            } catch {
+              /* already closed */
+            }
+          });
+        },
+      });
+      return new Response(stream, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+        },
+      });
+    }
+
     // GET /api/whoami — this host's device label (user@host), so a remote
     // console can tag each agent with the machine it came from. Unlike codehost,
     // `ay serve --share` carries no per-agent device id; the viewer fetches this

package/dist/SUPPORTED_CLIS-OeK9JJli.js

@@ -1,8 +0,0 @@
-import "./ts-gFuntNxO.js";
-import "./logger-B9h0djqx.js";
-import "./versionChecker-DlY0TAHI.js";
-import "./pidStore-DBjlqzo8.js";
-import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DxYk0BWq.js";
-
-export { SUPPORTED_CLIS };