agent-yes 1.113.0 → 1.115.0

package/README.md

@@ -24,7 +24,7 @@ Or with a package manager you already have:
 bun add -g agent-yes      # or: npm install -g agent-yes
 ```
 
-Then: `ay claude` (run an agent with auto-yes) · `ay serve share` (web console + shareable link) · live console at https://agent-yes.com
+Then: `ay claude` (run an agent with auto-yes) · `ay serve --share` (web console + shareable link) · live console at https://agent-yes.com
 
 ## Features
 

package/dist/SUPPORTED_CLIS-DUVB1HyL.js

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

package/dist/{SUPPORTED_CLIS-BpO7ZYx_.js → SUPPORTED_CLIS-VayLM5qX.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-ChVJOKNr.js";
+import { t as CLIS_CONFIG } from "./ts-B62nAAfY.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-BpO7ZYx_.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-VayLM5qX.js.map

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-wxlWV_VT.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-BdkE7S2A.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-DU5RXU0g.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-SOHKtDbk.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-DtJakX4G.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DUVB1HyL.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-ChVJOKNr.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-B62nAAfY.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-wxlWV_VT.js";
+import "./versionChecker-BdkE7S2A.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
 

package/dist/{serve-YPd9gtRO.js → serve-CP61tKuJ.js}

@@ -1,11 +1,11 @@
-import "./ts-ChVJOKNr.js";
+import "./ts-B62nAAfY.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-wxlWV_VT.js";
+import "./versionChecker-BdkE7S2A.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BpO7ZYx_.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-VayLM5qX.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-Za5uwCq6.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-t1uOb17r.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -176,6 +176,11 @@ Options:
 		description: "Deprecated no-op — the console can always spawn agents"
 	}).help(false).version(false).exitProcess(false).parseAsync();
 	if (argv.daemon) return cmdServeDaemon("install", rest.filter((a) => a !== "--daemon" && a !== "-d"));
+	const stray = argv._.map(String);
+	if (stray.length) {
+		const hint = stray.includes("share") ? " (did you mean --share?)" : "";
+		process.stderr.write(`ay serve: ignoring unknown argument${stray.length > 1 ? "s" : ""}: ${stray.join(" ")}${hint}\n`);
+	}
 	const port = argv.port ?? DEFAULT_PORT;
 	const host = argv.host ?? "127.0.0.1";
 	const tokenFlag = typeof argv.token === "string" ? argv.token : void 0;
@@ -220,6 +225,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,11 +289,7 @@ 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 });
 			}
@@ -258,10 +311,7 @@ Options:
 				const sent = /* @__PURE__ */ new Map();
 				const compute = async () => {
 					const records = await listRecords(keyword, opts);
-					return Promise.all(records.map(async (r) => ({
-						...r,
-						title: await logTitle(r.log_file)
-					})));
+					return Promise.all(records.map(withMeta));
 				};
 				const tick = async (first) => {
 					if (closed) return;
@@ -601,16 +651,18 @@ Options:
 		process.stdout.write(`  ay remote add <alias> ${scheme}://${token}@<host>:${port}\n\n`);
 		if (!useHttps) process.stdout.write("for HTTPS: ay serve --tls-cert cert.pem --tls-key key.pem\n  openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'\n\n");
 	}
+	let closeShare;
 	if (wantWebrtc) {
 		const webrtcVal = argv.webrtc ?? argv.share;
 		const explicitUrl = typeof webrtcVal === "string" && webrtcVal.startsWith("webrtc://") ? webrtcVal : void 0;
 		try {
-			const { startShare, loadOrCreateShareRoom } = await import("./share-BsCeIfQM.js");
-			const { link } = await startShare({
+			const { startShare, loadOrCreateShareRoom } = await import("./share-DwzKXEsJ.js");
+			const { link, close } = await startShare({
 				url: explicitUrl ?? await loadOrCreateShareRoom(),
 				localFetch: apiFetch,
 				apiToken: token
 			});
+			closeShare = close;
 			process.stdout.write(`${wantHttp ? "\n" : ""}shared over WebRTC — open this link (the token is eaten from the URL on open):\n  ${link}\n` + (explicitUrl ? "\n" : `  (persistent room — same link across restarts; delete ~/.agent-yes/.share-room to rotate)\n\n`));
 		} catch (e) {
 			process.stderr.write(`ay serve --webrtc failed: ${e.message}\n`);
@@ -620,10 +672,12 @@ Options:
 	process.stdout.write(`(Ctrl-C to stop)\n`);
 	await new Promise((resolve) => {
 		process.on("SIGINT", () => {
+			closeShare?.();
 			server?.stop();
 			resolve();
 		});
 		process.on("SIGTERM", () => {
+			closeShare?.();
 			server?.stop();
 			resolve();
 		});
@@ -633,4 +687,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-YPd9gtRO.js.map
+//# sourceMappingURL=serve-CP61tKuJ.js.map

package/dist/{share-BsCeIfQM.js → share-DwzKXEsJ.js}

@@ -68,8 +68,12 @@ async function startShare(opts) {
 	const wsScheme = host.startsWith("localhost") || host.startsWith("127.") ? "ws" : "wss";
 	const link = `${host === "s.agent-yes.com" ? "https://agent-yes.com" : "http://localhost:7778"}/#${room}:${token}${host === "s.agent-yes.com" ? "" : "@" + host}`;
 	const peers = /* @__PURE__ */ new Map();
+	let closed = false;
+	let currentWs;
 	const connectSignaling = (onReady) => {
+		if (closed) return;
 		const ws = new WebSocket(`${wsScheme}://${host}/${room}`, [SUB]);
+		currentWs = ws;
 		let ready = false;
 		ws.onopen = () => {
 			ws.send(JSON.stringify({
@@ -81,6 +85,7 @@ async function startShare(opts) {
 			onReady();
 		};
 		ws.onmessage = async (ev) => {
+			if (closed) return;
 			const m = JSON.parse(ev.data);
 			if (m.type === "peer-join") startPeer(ws, m.peer);
 			else if (m.type === "answer") await peers.get(m.from)?.pc.setRemoteDescription({
@@ -91,6 +96,7 @@ async function startShare(opts) {
 			else if (m.type === "peer-leave") closePeer(m.peer);
 		};
 		ws.onclose = () => {
+			if (closed) return;
 			setTimeout(() => connectSignaling(() => {}), ready ? 1500 : 4e3);
 		};
 		ws.onerror = () => {};
@@ -135,7 +141,10 @@ async function startShare(opts) {
 		peers.delete(peerId);
 	}
 	function send(dc, obj) {
-		if (dc.readyState === "open") dc.send(JSON.stringify(obj));
+		if (dc.readyState !== "open") return;
+		try {
+			dc.send(JSON.stringify(obj));
+		} catch {}
 	}
 	async function onReq(dc, aborts, req) {
 		if (req.t === "abort") {
@@ -190,12 +199,20 @@ async function startShare(opts) {
 		}
 	}
 	await new Promise((resolve) => connectSignaling(resolve));
+	const close = () => {
+		closed = true;
+		try {
+			currentWs?.close();
+		} catch {}
+		for (const peerId of [...peers.keys()]) closePeer(peerId);
+	};
 	return {
 		room,
-		link
+		link,
+		close
 	};
 }
 
 //#endregion
 export { loadOrCreateShareRoom, startShare };
-//# sourceMappingURL=share-BsCeIfQM.js.map
+//# sourceMappingURL=share-DwzKXEsJ.js.map

package/dist/{subcommands-DU5RXU0g.js → subcommands-SOHKtDbk.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-Za5uwCq6.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-t1uOb17r.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-Za5uwCq6.js → subcommands-t1uOb17r.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-YPd9gtRO.js");
+				const { cmdServe } = await import("./serve-CP61tKuJ.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-Za5uwCq6.js.map
+//# sourceMappingURL=subcommands-t1uOb17r.js.map

package/dist/{ts-ChVJOKNr.js → ts-B62nAAfY.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-wxlWV_VT.js";
+import { r as getInstalledPackage } from "./versionChecker-BdkE7S2A.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-ChVJOKNr.js.map
+//# sourceMappingURL=ts-B62nAAfY.js.map

package/dist/{versionChecker-wxlWV_VT.js → versionChecker-BdkE7S2A.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.113.0";
+var version = "1.115.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-wxlWV_VT.js.map
+//# sourceMappingURL=versionChecker-BdkE7S2A.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;
@@ -737,6 +748,7 @@
     />
     <script src="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/lib/xterm.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/@xterm/addon-fit@0.10.0/lib/addon-fit.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/@xterm/addon-web-links@0.11.0/lib/addon-web-links.min.js"></script>
     <script type="module">
       // codehost room transport — vendored from codehost's `bun run build:lib`.
       // Loaded as a module (deferred), so the classic script below awaits the
@@ -821,6 +833,7 @@
         repoBranch,
         ident,
         tagsFor,
+        gitLabel,
         age,
         matches,
         nextIndex,
@@ -909,6 +922,7 @@
         connect() {
           return new Promise((resolve, reject) => {
             const ws = new WebSocket(`wss://${this.host}/${this.room}`, [SUB]);
+            this.ws = ws; // kept so close() can drop the signaling registration too
             let pc,
               settled = false;
             const fail = (e) => {
@@ -966,6 +980,7 @@
             if (stream) stream(r.chunk);
           } else if (r.t === "end") {
             if (call) {
+              clearTimeout(call.timer);
               this.calls.delete(r.id);
               r.error
                 ? call.reject(new Error(r.error))
@@ -976,8 +991,21 @@
         req(method, path, body) {
           const id = this.nextId++;
           return new Promise((resolve, reject) => {
-            this.calls.set(id, { status: 0, body: "", resolve, reject });
-            this.dc.send(JSON.stringify({ t: "req", id, method, path, body }));
+            // Without a deadline a request over a silently-dead DataChannel (host
+            // gone, ICE not yet timed out) never settles, so the caller — and the
+            // poll loop — hangs forever and the room never reconnects. Reject on a
+            // timeout so listSource sees the failure and triggers backoff.
+            const timer = setTimeout(() => {
+              if (this.calls.delete(id)) reject(new Error("request timed out"));
+            }, 12000);
+            this.calls.set(id, { status: 0, body: "", resolve, reject, timer });
+            try {
+              this.dc.send(JSON.stringify({ t: "req", id, method, path, body }));
+            } catch (e) {
+              clearTimeout(timer);
+              this.calls.delete(id);
+              reject(e); // channel already torn down
+            }
           });
         }
         subscribe(path, onRaw) {
@@ -991,6 +1019,26 @@
             } catch {}
           };
         }
+        // Tear down BOTH wires. Closing only the pc leaves the signaling socket
+        // open and this client registered in the room, so each reconnect would
+        // leak another peer on the host. onstate is detached by the caller first.
+        close() {
+          try {
+            this.ws?.close();
+          } catch {}
+          try {
+            this.pc?.close();
+          } catch {}
+          this.dc = null;
+          // Settle anything still in flight now, rather than letting each req's
+          // 12s timeout fire long after the client is gone.
+          for (const c of this.calls.values()) {
+            clearTimeout(c.timer);
+            c.reject(new Error("connection closed"));
+          }
+          this.calls.clear();
+          this.streams.clear();
+        }
       }
 
       // ---- codehost rooms: a THIRD wire -----------------------------------
@@ -1298,6 +1346,11 @@
           s.serverCount = 0;
           s.byPid = new Map();
           s.agents = [];
+          // A failed poll on an agent-yes room means the tunnel is unresponsive
+          // (host gone/restarted) — the fastest, most reliable drop signal we get,
+          // since WebRTC's own failed/closed state can lag 15-30s. Kick off the
+          // backoff reconnect (no-op if one's already queued or the room's gone).
+          if (s.kind === "rtc") scheduleRtcReconnect(s);
           return [];
         }
       }
@@ -1333,6 +1386,16 @@
       // 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));
@@ -1355,6 +1418,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>`;
@@ -1376,6 +1440,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>` : ""}
@@ -1513,6 +1578,19 @@
         });
         fit = new FitAddon.FitAddon();
         term.loadAddon(fit);
+        // Make plain URLs in the output clickable. Agents that emit OSC 8
+        // hyperlinks already get clickable text, but most output is bare URLs —
+        // this addon scans the rendered buffer and links them too. Click opens a
+        // new tab (noopener so the page can't be tampered with via window.opener).
+        try {
+          term.loadAddon(
+            new WebLinksAddon.WebLinksAddon((e, uri) =>
+              window.open(uri, "_blank", "noopener,noreferrer"),
+            ),
+          );
+        } catch {
+          /* addon CDN blocked — terminal still works, just without auto-links */
+        }
         term.open(logEl);
         // On a phone, auto-focusing yanks up the soft keyboard the moment you open
         // an agent — even when you only meant to read the tail. Skip it there; a tap
@@ -1709,6 +1787,8 @@
       function removeSource(room) {
         const s = sources.get(room);
         if (!s) return;
+        s.removed = true; // stop any pending exp-backoff reconnect (see below)
+        clearTimeout(s.reconnectTimer);
         unsubscribeSource(s);
         try {
           s.client?.close?.();
@@ -1717,6 +1797,97 @@
         sources.delete(room);
       }
 
+      // Exponential-backoff reconnect for an agent-yes share room (the RTCClient
+      // wire). codehost rooms already self-heal via room-client.js; the agent-yes
+      // viewer was one-shot, so a dropped DataChannel (e.g. the host restarting)
+      // left the room dead until a manual reload. Retry with jittered backoff
+      // until the room is forgotten.
+      const RTC_BACKOFF_MIN = 1000,
+        RTC_BACKOFF_MAX = 30000;
+      async function connectRtcSource(s) {
+        s.reconnecting = true; // block overlapping attempts while this one is in flight
+        try {
+          // Detach the stale peer's onstate BEFORE closing it — otherwise its own
+          // "closed" event schedules another reconnect mid-replace, and that timer
+          // fires after we've already recovered, churning a healthy channel forever.
+          if (s.client) s.client.onstate = () => {};
+          // The delta stream died silently with the old client (RTCClient never
+          // fires onError), leaving s.streaming=true and s.unsub set — which would
+          // make the reconcile poll skip this source AND block re-subscription.
+          // Clear it so the fresh transport below re-establishes the stream.
+          unsubscribeSource(s);
+          try {
+            s.client?.close?.(); // drop the stale peer AND its signaling socket
+          } catch {}
+          const c = new RTCClient(s.host, s.id, s.token);
+          c.onstate = (st) => {
+            if (st === "failed" || st === "closed") {
+              s.live = false;
+              renderRoomsIfOpen();
+              scheduleRtcReconnect(s); // "disconnected" is transient; ignore it
+            }
+          };
+          try {
+            await c.connect();
+          } catch (e) {
+            c.close(); // connect() already opened the signaling socket — don't
+            throw e; //  leak it on every failed retry of an offline room
+          }
+          if (s.removed) {
+            c.close(); // room was forgotten mid-connect — don't install/leak it
+            return;
+          }
+          s.client = c;
+          s.tx = rtcTx(c);
+          s.reconnectDelay = RTC_BACKOFF_MIN; // a healthy connect resets the backoff
+          clearTimeout(s.reconnectTimer); // cancel any reconnect queued during replace
+          s.reconnectTimer = null;
+          subscribeSource(s); // re-establish the live delta stream over the new wire
+          // agent-yes share (unlike codehost) sends no per-agent device id, so
+          // every machine's rows would be unlabelled. Ask the host who it is once
+          // and tag this room's agents with it in listSource. Best-effort: an older
+          // host with no /api/whoami just leaves rows device-less.
+          try {
+            s.deviceLabel = (await s.tx.fetchJSON("/api/whoami"))?.host || "";
+            // whoami resolves after the first listSource may have already rendered
+            // this room's rows device-less (and activity-gated polling might not
+            // re-fire soon on a backgrounded tab). Re-render now so the host label
+            // lands immediately instead of lagging a poll.
+            if (s.deviceLabel) loadList();
+          } catch {
+            s.deviceLabel = "";
+          }
+        } finally {
+          s.reconnecting = false;
+        }
+      }
+      function scheduleRtcReconnect(s) {
+        // forgotten, already queued, or a connect is already in flight
+        if (s.removed || s.reconnectTimer || s.reconnecting) return;
+        const base = s.reconnectDelay || RTC_BACKOFF_MIN;
+        const delay = Math.round(base * (0.75 + Math.random() * 0.5)); // jitter
+        s.reconnectDelay = Math.min(base * 2, RTC_BACKOFF_MAX);
+        s.reconnectTimer = setTimeout(async () => {
+          s.reconnectTimer = null;
+          if (s.removed || s.reconnecting) return;
+          try {
+            await connectRtcSource(s);
+            s.live = true;
+            renderRoomsIfOpen();
+            // Await the refresh: a prior failed poll cleared `entries`, so select()
+            // below would find nothing and skip the rebind until the list is back.
+            await loadList();
+            // A terminal opened before the drop still holds the dead tx (its tail
+            // subscription + send closures). Re-select to rebind it to the new
+            // transport, else the room looks live but the terminal stays frozen.
+            if (sel && sel.startsWith(s.id + "#")) select(sel);
+          } catch {
+            s.live = false;
+            scheduleRtcReconnect(s); // keep trying
+          }
+        }, delay);
+      }
+
       // Add a room to the fleet and connect it — WITHOUT dropping the others, so
       // every saved room streams its agents at once. Idempotent: a room already
       // in the fleet just refreshes. The connection runs in the background; the
@@ -1751,29 +1922,13 @@
             s.client = c;
             s.tx = c;
           } else {
-            const c = new RTCClient(host, room, token);
-            c.onstate = (st) => {
-              if (st === "failed" || st === "closed") {
-                s.live = false;
-                renderRoomsIfOpen();
-              }
-            };
-            await c.connect();
-            s.client = c;
-            s.tx = rtcTx(c);
-            // agent-yes share (unlike codehost) sends no per-agent device id, so
-            // every machine's rows would be unlabelled. Ask the host who it is
-            // once and tag this room's agents with it in listSource. Best-effort:
-            // an older host with no /api/whoami just leaves rows device-less.
-            try {
-              s.deviceLabel = (await s.tx.fetchJSON("/api/whoami"))?.host || "";
-            } catch {
-              s.deviceLabel = "";
-            }
+            s.token = token;
+            await connectRtcSource(s);
           }
           s.live = true;
         } catch (e) {
           s.live = false;
+          if (s.kind === "rtc") scheduleRtcReconnect(s);
         }
         s.tried = true;
         renderRoomsIfOpen();
@@ -1843,7 +1998,7 @@
         <span style="opacity:.6">Windows:</span>
         <code id="cmdinstallwin" class="copy" title="click to copy">powershell -c "irm https://agent-yes.com/setup.ps1 | iex"</code></div>
       <div class="rconnect">share your own fleet — run this, then open the printed link:
-        <code id="cmd" class="copy" title="click to copy">ay serve share</code></div>
+        <code id="cmd" class="copy" title="click to copy">ay serve --share</code></div>
       <div class="rconnect">or view a <b>codehost</b> room — paste <code>ch:&lt;room-token&gt;</code> (or a
         codehost.dev share link) above; every machine in the room shows its agents here.</div>`;
       }

package/package.json

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

@@ -228,6 +228,18 @@ export async function cmdServe(rest: string[]): Promise<number> {
     return cmdServeDaemon("install", fwd);
   }
 
+  // `ay serve` takes only flags (plus the install/uninstall/logs subcommands
+  // handled above). A bare word like `ay serve share` is silently dropped into
+  // argv._ by yargs and would otherwise start in the wrong mode — most often
+  // it's a typo for the `--share` flag — so warn instead of quietly ignoring it.
+  const stray = (argv._ as Array<string | number>).map(String);
+  if (stray.length) {
+    const hint = stray.includes("share") ? " (did you mean --share?)" : "";
+    process.stderr.write(
+      `ay serve: ignoring unknown argument${stray.length > 1 ? "s" : ""}: ${stray.join(" ")}${hint}\n`,
+    );
+  }
+
   const port = (argv.port as number) ?? DEFAULT_PORT;
   const host = (argv.host as string) ?? "127.0.0.1";
   const tokenFlag = typeof argv.token === "string" ? argv.token : undefined;
@@ -291,6 +303,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,10 +379,7 @@ 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 });
       }
@@ -348,9 +413,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
           const sent = new Map<number, string>();
           const compute = async () => {
             const records = await listRecords(keyword, opts);
-            return Promise.all(
-              records.map(async (r) => ({ ...r, title: await logTitle(r.log_file) })),
-            );
+            return Promise.all(records.map(withMeta));
           };
           const tick = async (first: boolean) => {
             if (closed) return;
@@ -777,6 +840,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // can reach this machine peer-to-peer. The bridge calls apiFetch in-process,
   // so without --http no port is opened at all. Bare flag mints a room; a
   // webrtc:// value joins an explicit one.
+  let closeShare: (() => void) | undefined; // closes WebRTC peers on shutdown
   if (wantWebrtc) {
     const webrtcVal = (argv.webrtc ?? argv.share) as string | undefined;
     const explicitUrl =
@@ -785,11 +849,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
       const { startShare, loadOrCreateShareRoom } = await import("./share.ts");
       // No explicit webrtc:// URL → reuse the persisted room (minted once and
       // saved like the serve token), so the link is stable across restarts.
-      const { link } = await startShare({
+      const { link, close } = await startShare({
         url: explicitUrl ?? (await loadOrCreateShareRoom()),
         localFetch: apiFetch,
         apiToken: token,
       });
+      closeShare = close;
       process.stdout.write(
         `${wantHttp ? "\n" : ""}shared over WebRTC — open this link (the token is eaten from the URL on open):\n  ${link}\n` +
           (explicitUrl
@@ -806,10 +871,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
 
   await new Promise<void>((resolve) => {
     process.on("SIGINT", () => {
+      closeShare?.();
       server?.stop();
       resolve();
     });
     process.on("SIGTERM", () => {
+      closeShare?.();
       server?.stop();
       resolve();
     });

package/ts/share.ts

@@ -90,7 +90,9 @@ async function importRTC(): Promise<any> {
 
 /** Start the share bridge. Resolves once signaling is connected; runs until the
  *  process exits, reconnecting signaling on drop. Returns the shareable link. */
-export async function startShare(opts: ShareOpts): Promise<{ room: string; link: string }> {
+export async function startShare(
+  opts: ShareOpts,
+): Promise<{ room: string; link: string; close: () => void }> {
   const minted = !opts.url;
   const sighost = opts.sighost ?? DEFAULT_SIGHOST;
   const { room, token, host } = opts.url
@@ -109,9 +111,13 @@ export async function startShare(opts: ShareOpts): Promise<{ room: string; link:
 
   type Peer = { pc: any; aborts: Map<number, AbortController> };
   const peers = new Map<string, Peer>();
+  let closed = false; // set by close(); stops signaling reconnect + new peers
+  let currentWs: WebSocket | undefined; // the live rendezvous socket, for close()
 
   const connectSignaling = (onReady: () => void) => {
+    if (closed) return; // a reconnect timer queued before close() must not revive it
     const ws = new WebSocket(`${wsScheme}://${host}/${room}`, [SUB]);
+    currentWs = ws;
     let ready = false;
     ws.onopen = () => {
       ws.send(JSON.stringify({ type: "hello", role: "host", token }));
@@ -119,6 +125,7 @@ export async function startShare(opts: ShareOpts): Promise<{ room: string; link:
       onReady();
     };
     ws.onmessage = async (ev) => {
+      if (closed) return;
       const m = JSON.parse(ev.data as string);
       if (m.type === "peer-join") startPeer(ws, m.peer);
       else if (m.type === "answer")
@@ -131,6 +138,7 @@ export async function startShare(opts: ShareOpts): Promise<{ room: string; link:
       else if (m.type === "peer-leave") closePeer(m.peer);
     };
     ws.onclose = () => {
+      if (closed) return; // shutting down — don't resurrect the rendezvous
       // Keep established WebRTC peers; just re-establish the rendezvous so new
       // browsers can still join. Backoff a little to avoid hot-looping.
       setTimeout(() => connectSignaling(() => {}), ready ? 1500 : 4000);
@@ -172,7 +180,16 @@ export async function startShare(opts: ShareOpts): Promise<{ room: string; link:
   }
 
   function send(dc: any, obj: object) {
-    if (dc.readyState === "open") dc.send(JSON.stringify(obj));
+    // readyState alone is racy: node-datachannel can still report "open" for a
+    // tick after a dropped peer's channel is torn down underneath, so dc.send()
+    // throws "DataChannel is closed". Swallow it — the frame is for a peer that's
+    // already gone (closePeer aborts its in-flight requests right behind this).
+    if (dc.readyState !== "open") return;
+    try {
+      dc.send(JSON.stringify(obj));
+    } catch {
+      /* peer vanished mid-send; dropping the frame is correct */
+    }
   }
 
   async function onReq(dc: any, aborts: Map<number, AbortController>, req: any) {
@@ -218,5 +235,19 @@ export async function startShare(opts: ShareOpts): Promise<{ room: string; link:
 
   await new Promise<void>((resolve) => connectSignaling(resolve));
   void minted; // (informational) caller decides how to surface the link
-  return { room, link };
+
+  // Clean shutdown: stop the rendezvous (so it can't reconnect or accept new
+  // peers) and close every peer connection so browsers get an immediate
+  // DataChannel close and reconnect right away, instead of waiting out the
+  // ~15-30s ICE timeout that an abrupt process exit would otherwise force.
+  const close = () => {
+    closed = true;
+    try {
+      currentWs?.close();
+    } catch {
+      /* already closing */
+    }
+    for (const peerId of [...peers.keys()]) closePeer(peerId);
+  };
+  return { room, link, close };
 }

package/dist/SUPPORTED_CLIS-DtJakX4G.js

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