agent-yes 1.115.1 → 1.117.0

package/dist/SUPPORTED_CLIS-DK9PO6Y6.js

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

package/dist/{SUPPORTED_CLIS-Co1JpoEr.js → SUPPORTED_CLIS-DQYx5cvl.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-8yOJK-_k.js";
+import { t as CLIS_CONFIG } from "./ts-B4lhxCQx.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-Co1JpoEr.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DQYx5cvl.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-Coc3Y6Q5.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-CS7qsffQ.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-BpU68RGV.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-BuLieGot.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-DF0iApn5.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DK9PO6Y6.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-8yOJK-_k.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-B4lhxCQx.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-Coc3Y6Q5.js";
+import "./versionChecker-CS7qsffQ.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
 

package/dist/{serve-D7Hj5j6W.js → serve-DJthZQAN.js}

@@ -1,11 +1,11 @@
-import "./ts-8yOJK-_k.js";
+import "./ts-B4lhxCQx.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-Coc3Y6Q5.js";
+import { r as getInstalledPackage } from "./versionChecker-CS7qsffQ.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Co1JpoEr.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DQYx5cvl.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-b3HW9zZo.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-B_JJRHkV.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -51,7 +51,84 @@ const defaultOpts = (overrides = {}) => ({
 	cwdScope: null,
 	...overrides
 });
+const SESSION_PIN_ENV = new Set([
+	"CLAUDECODE",
+	"CLAUDE_CODE_SSE_PORT",
+	"CLAUDE_CODE_SESSION_ID",
+	"CLAUDE_CODE_CHILD_SESSION",
+	"CLAUDE_CODE_ENTRYPOINT"
+]);
+function freshAgentEnv() {
+	const env = {};
+	for (const [k, v] of Object.entries(process.env)) {
+		if (v === void 0 || SESSION_PIN_ENV.has(k)) continue;
+		env[k] = v;
+	}
+	return env;
+}
 const DAEMON_NAME = "agent-yes";
+async function ensureBootAutostart(oxmgrBin) {
+	try {
+		return await Bun.spawn([
+			oxmgrBin,
+			"service",
+			"install"
+		], { stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		] }).exited === 0;
+	} catch {
+		return false;
+	}
+}
+async function spawnExit(cmd) {
+	try {
+		return await Bun.spawn(cmd, { stdio: [
+			"ignore",
+			"ignore",
+			"ignore"
+		] }).exited ?? 1;
+	} catch {
+		return 1;
+	}
+}
+async function readDaemonServeArgs(oxmgrBin) {
+	try {
+		const p = Bun.spawn([
+			oxmgrBin,
+			"status",
+			DAEMON_NAME
+		], {
+			stdout: "pipe",
+			stderr: "ignore"
+		});
+		const out = await new Response(p.stdout).text();
+		if (await p.exited !== 0) return null;
+		const m = /Command:\s*(.+)/.exec(out);
+		if (!m) return null;
+		const after = /\bserve\b\s*(.*)$/.exec(m[1].trim());
+		return after ? after[1].split(/\s+/).filter(Boolean) : [];
+	} catch {
+		return null;
+	}
+}
+function portFromArgs(args) {
+	const m = /--port[=\s](\d+)/.exec(args.join(" "));
+	return m ? Number(m[1]) : DEFAULT_PORT;
+}
+async function fetchDaemonVersion(port, token) {
+	try {
+		const r = await fetch(`http://127.0.0.1:${port}/api/version`, {
+			headers: { Authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(3e3)
+		});
+		if (!r.ok) return null;
+		return (await r.json()).version ?? null;
+	} catch {
+		return null;
+	}
+}
 async function cmdServeDaemon(sub, args) {
 	const oxmgrBin = Bun.which("oxmgr");
 	if (!oxmgrBin) {
@@ -60,11 +137,33 @@ async function cmdServeDaemon(sub, args) {
 	}
 	if (sub === "install") {
 		const token = await loadOrCreateToken(void 0);
+		const priorArgs = await readDaemonServeArgs(oxmgrBin);
+		const effArgs = args.length ? args : priorArgs ?? [];
+		const current = getInstalledPackage().version;
+		if (priorArgs !== null) {
+			const runningVer = await fetchDaemonVersion(portFromArgs(effArgs), token);
+			if (runningVer === current) {
+				await ensureBootAutostart(oxmgrBin);
+				process.stdout.write(`'${DAEMON_NAME}' already running v${current} (up to date)\n`);
+				return 0;
+			}
+			process.stdout.write(`rolling '${DAEMON_NAME}' ${runningVer ? `v${runningVer}` : "(unknown)"} → v${current}…\n`);
+			await spawnExit([
+				oxmgrBin,
+				"stop",
+				DAEMON_NAME
+			]);
+			await spawnExit([
+				oxmgrBin,
+				"delete",
+				DAEMON_NAME
+			]);
+		}
 		const ayBin = Bun.which("ay");
 		const serveCmd = [
 			...ayBin ? [process.execPath, ayBin] : ["ay"],
 			"serve",
-			...args
+			...effArgs
 		].join(" ");
 		const code = await Bun.spawn([
 			oxmgrBin,
@@ -80,11 +179,12 @@ async function cmdServeDaemon(sub, args) {
 			"inherit"
 		] }).exited;
 		if (code === 0) {
-			const portM = /--port[=\s](\d+)/.exec(args.join(" "));
-			const port = portM ? Number(portM[1]) : DEFAULT_PORT;
-			const webrtcish = args.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
-			const httpish = args.some((a) => a.startsWith("--http") || a.startsWith("--share")) || !args.some((a) => a.startsWith("--webrtc"));
-			process.stdout.write(`\ninstalled '${DAEMON_NAME}' as a daemon via oxmgr\n`);
+			const onBoot = await ensureBootAutostart(oxmgrBin);
+			const port = portFromArgs(effArgs);
+			const webrtcish = effArgs.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
+			const httpish = effArgs.some((a) => a.startsWith("--http") || a.startsWith("--share")) || !effArgs.some((a) => a.startsWith("--webrtc"));
+			process.stdout.write(`\n${priorArgs !== null ? `rolled '${DAEMON_NAME}' forward to` : `installed '${DAEMON_NAME}' as a daemon via oxmgr —`} v${current}\n`);
+			process.stdout.write(onBoot ? `start-on-boot: enabled (oxmgr registered with the system init)\n` : `start-on-boot: not registered — run \`oxmgr service install\` to enable\n`);
 			process.stdout.write(`token: ${token}\n\n`);
 			if (httpish) {
 				process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
@@ -372,6 +472,7 @@ Options:
 			const host = hostname();
 			return Response.json({ host: user ? `${user}@${host}` : host });
 		}
+		if (req.method === "GET" && p === "/api/version") return Response.json({ version: getInstalledPackage().version });
 		if (req.method === "GET" && p === "/api/notes") {
 			const notes = await readNotes();
 			return Response.json(Object.fromEntries(notes));
@@ -583,6 +684,7 @@ Options:
 					...prompt ? ["--", prompt] : []
 				], {
 					cwd,
+					env: freshAgentEnv(),
 					stdin: "ignore",
 					stdout: "ignore",
 					stderr: "ignore"
@@ -687,4 +789,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-D7Hj5j6W.js.map
+//# sourceMappingURL=serve-DJthZQAN.js.map

package/dist/{subcommands-b3HW9zZo.js → subcommands-B_JJRHkV.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-D7Hj5j6W.js");
+				const { cmdServe } = await import("./serve-DJthZQAN.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-b3HW9zZo.js.map
+//# sourceMappingURL=subcommands-B_JJRHkV.js.map

package/dist/{subcommands-BpU68RGV.js → subcommands-BuLieGot.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-b3HW9zZo.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-B_JJRHkV.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{ts-8yOJK-_k.js → ts-B4lhxCQx.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-Coc3Y6Q5.js";
+import { r as getInstalledPackage } from "./versionChecker-CS7qsffQ.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";
@@ -1713,4 +1713,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-8yOJK-_k.js.map
+//# sourceMappingURL=ts-B4lhxCQx.js.map

package/dist/{versionChecker-Coc3Y6Q5.js → versionChecker-CS7qsffQ.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.115.1";
+var version = "1.117.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-Coc3Y6Q5.js.map
+//# sourceMappingURL=versionChecker-CS7qsffQ.js.map

package/lab/ui/index.html

@@ -1545,6 +1545,15 @@
         try {
           localStorage.setItem("ay.sel", sel);
         } catch {}
+        // Reflect it in the URL hash as #room:pid. The fragment is never sent in
+        // any request, so — unlike the old ?pid= query that landed in the server's
+        // access logs — the agent id stays client-side, while still surviving a
+        // refresh and being copy-pasteable as a deep link.
+        try {
+          const want = "#" + e._room + ":" + e.pid;
+          if (location.hash !== want)
+            history.replaceState(null, document.title, location.pathname + want);
+        } catch {}
         // pid + tx are how we talk to the agent's own host; sel (composite) is
         // only for UI identity/highlight, since pids can collide across rooms.
         const pid = e.pid;
@@ -1618,10 +1627,11 @@
         });
         // Adapt: drive the agent's PTY to the browser terminal size (POST
         // /api/resize → winsize + SIGWINCH) so its TUI reflows to match what we
-        // render. Suppressed while we're merely adopting the agent's OWN size.
-        let adoptingAgentSize = false;
+        // render. Suppressed during the initial fit below, which does its own
+        // one-shot "push only if the agent is out of sync" check.
+        let suppressPush = true;
         const pushSize = () => {
-          if (term && sel === e._key && !adoptingAgentSize)
+          if (term && sel === e._key && !suppressPush)
             tx.post("/api/resize/" + encodeURIComponent(pid), {
               cols: term.cols,
               rows: term.rows,
@@ -1642,28 +1652,32 @@
         };
         term.onData(fwd);
         term.onBinary(fwd);
-        // Render the existing buffer at the AGENT's current width first so its
-        // wrapping is correct, instead of forcing our viewport width onto stale
-        // content. The user adapts to the window by resizing it (fit → push).
+        // On switch, render at OUR pane size and make the agent match it: fit
+        // xterm to the viewport, then — if the agent's PTY winsize differs from
+        // what we're now rendering — push a resize so its TUI reflows to fill the
+        // pane. The agent may have been sized by a different viewer/terminal, or
+        // our window changed while this agent was in the background; either way a
+        // mismatch leaves the TUI clipped or boxed-in until something nudges it.
+        // Only push when it actually differs, so an already-matching agent isn't
+        // poked with a redundant SIGWINCH. After this, live window resizes push
+        // automatically (suppressPush flips off).
         const selKey = e._key;
+        const fitAndSync = (sz) => {
+          if (sel !== selKey || !term) return;
+          try {
+            fit.fit();
+          } catch {}
+          if (!sz || sz.cols !== term.cols || sz.rows !== term.rows) {
+            tx.post("/api/resize/" + encodeURIComponent(pid), {
+              cols: term.cols,
+              rows: term.rows,
+            }).catch(() => {});
+          }
+          suppressPush = false;
+        };
         tx.fetchJSON("/api/size/" + encodeURIComponent(pid))
-          .then((sz) => {
-            if (sel !== selKey || !term) return;
-            if (sz && sz.cols && sz.rows) {
-              adoptingAgentSize = true;
-              term.resize(sz.cols, sz.rows);
-              adoptingAgentSize = false;
-            } else {
-              try {
-                fit.fit();
-              } catch {}
-            }
-          })
-          .catch(() => {
-            try {
-              fit.fit();
-            } catch {}
-          });
+          .then(fitAndSync)
+          .catch(() => fitAndSync(null));
 
         // True live tail via ay serve's SSE stream. First event is an xterm-rendered
         // tail snapshot; later events are incremental deltas. We normalise terminal
@@ -2251,7 +2265,23 @@
         }
         const full = pending ? null : /^([A-Za-z0-9_-]+):([^@]+)(?:@(.+))?$/.exec(h);
         const bare = /^([A-Za-z0-9_-]+)$/.exec(h);
-        if (full) {
+        // Treat the colon form as #room:agentId only when there's no @host, the id
+        // is a bare pid (digits), AND we can actually reconnect that room (it's
+        // cached or local). Otherwise the second part must be the token we need to
+        // connect — so a fresh browser still honours #room:token even when the token
+        // is custom and happens to be all digits.
+        // …and bounded to a plausible pid width (≤7 digits) so a long numeric
+        // custom token can't be mistaken for an agent id. A returning user's room
+        // token is persisted, so even a short numeric token reconnects fine from
+        // cache; only the share-link form needs the token, which stays uneaten.
+        const aidLike =
+          full &&
+          !full[3] &&
+          /^\d{1,7}$/.test(full[2]) &&
+          (full[1] === LOCAL || !!loadRooms()[full[1]]);
+        if (full && !aidLike) {
+          // #room:token — a share link. Connect, then eat the token so only #room
+          // lingers.
           const [, room, token, host] = full;
           // SECURITY: strip the token from the URL immediately so it never lingers in
           // the omnibox, history, or a screenshot. Keep only the room mnemonic.
@@ -2261,6 +2291,16 @@
             location.pathname + location.search + "#" + room,
           );
           pending = { room, token, host };
+        } else if (full) {
+          // #room:agentId — a deep link to one agent in a (cached) room. The id is
+          // not a secret, so it stays in the hash; reconnect the room from its
+          // cached token and select the agent once it streams in. autoPid uses the
+          // composite key so it picks the right host when pids collide across rooms.
+          const [, room, aid] = full;
+          autoPid = room + "#" + aid;
+          autoPidExplicit = true;
+          const r = loadRooms()[room];
+          if (r) pending = { room, token: r.token, host: r.host };
         } else if (bare && loadRooms()[bare[1]]) {
           const r = loadRooms()[bare[1]];
           pending = { room: bare[1], token: r.token, host: r.host };

package/package.json

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

@@ -16,6 +16,7 @@ import {
   type CommonOpts,
 } from "./subcommands.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
+import { getInstalledPackage } from "./versionChecker.ts";
 
 const DEFAULT_PORT = 7432;
 
@@ -64,12 +65,104 @@ const defaultOpts = (overrides: Partial<CommonOpts> = {}): CommonOpts => ({
   ...overrides,
 });
 
+// The vars that pin a process to a PARENT Claude Code session — NOT the many
+// other CLAUDE_CODE_* settings that configure provider/auth/limits (USE_BEDROCK,
+// USE_VERTEX, MAX_OUTPUT_TOKENS, …), which must pass through untouched.
+const SESSION_PIN_ENV = new Set([
+  "CLAUDECODE",
+  "CLAUDE_CODE_SSE_PORT",
+  "CLAUDE_CODE_SESSION_ID",
+  "CLAUDE_CODE_CHILD_SESSION",
+  "CLAUDE_CODE_ENTRYPOINT",
+]);
+
+// Env for a console-spawned agent, minus only the session-pinning vars above. If
+// `ay serve` was launched from inside Claude Code (or any shell carrying these),
+// it would otherwise leak the parent's SSE port / session id into every spawned
+// agent — so the new `claude` thinks it's a nested child and tries to attach to a
+// stale port, surfacing as "fail to connect". Dropping them makes each agent a
+// clean top-level session; all config/provider env (CLAUDE_EFFORT, CLAUDE_CODE_*
+// settings) is preserved.
+function freshAgentEnv(): Record<string, string> {
+  const env: Record<string, string> = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === undefined || SESSION_PIN_ENV.has(k)) continue;
+    env[k] = v;
+  }
+  return env;
+}
+
 // ---------------------------------------------------------------------------
 // ay serve install / uninstall / logs  (oxmgr daemon management)
 // ---------------------------------------------------------------------------
 
 const DAEMON_NAME = "agent-yes";
 
+// Register the oxmgr daemon with the platform init system (launchd on macOS,
+// systemd on Linux, Task Scheduler on Windows) so managed processes — including
+// the agent-yes daemon — come back after a *reboot*, not just a crash. Idempotent:
+// a no-op if the service is already installed. Best-effort: returns false on any
+// failure (e.g. a system-level systemd unit that needs sudo) without aborting the
+// install — the process is still managed, just not boot-persistent.
+async function ensureBootAutostart(oxmgrBin: string): Promise<boolean> {
+  try {
+    // --system defaults to "auto" (launchd/systemd/Task Scheduler by platform);
+    // it's a `service`-level flag, so passing it after `install` is rejected.
+    const svc = Bun.spawn([oxmgrBin, "service", "install"], {
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+    return (await svc.exited) === 0;
+  } catch {
+    return false;
+  }
+}
+
+async function spawnExit(cmd: string[]): Promise<number> {
+  try {
+    return (await Bun.spawn(cmd, { stdio: ["ignore", "ignore", "ignore"] }).exited) ?? 1;
+  } catch {
+    return 1;
+  }
+}
+
+// The `serve` args the running daemon was started with, parsed out of oxmgr's
+// stored command line (`… ay serve --share --port 7433`). null when no daemon is
+// registered. Lets a bare `ay serve install` re-launch with the SAME args.
+async function readDaemonServeArgs(oxmgrBin: string): Promise<string[] | null> {
+  try {
+    const p = Bun.spawn([oxmgrBin, "status", DAEMON_NAME], { stdout: "pipe", stderr: "ignore" });
+    const out = await new Response(p.stdout).text();
+    if ((await p.exited) !== 0) return null;
+    const m = /Command:\s*(.+)/.exec(out);
+    if (!m) return null;
+    const after = /\bserve\b\s*(.*)$/.exec(m[1]!.trim());
+    return after ? after[1]!.split(/\s+/).filter(Boolean) : [];
+  } catch {
+    return null;
+  }
+}
+
+function portFromArgs(args: string[]): number {
+  const m = /--port[=\s](\d+)/.exec(args.join(" "));
+  return m ? Number(m[1]) : DEFAULT_PORT;
+}
+
+// Ask the live daemon its version over the local HTTP API. null if it's not
+// listening (webrtc-only) or too old to expose /api/version — both of which we
+// treat as "outdated" so a re-install rolls it forward.
+async function fetchDaemonVersion(port: number, token: string): Promise<string | null> {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/api/version`, {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!r.ok) return null;
+    return ((await r.json()) as { version?: string }).version ?? null;
+  } catch {
+    return null;
+  }
+}
+
 async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
   const oxmgrBin = Bun.which("oxmgr");
   if (!oxmgrBin) {
@@ -83,25 +176,61 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
 
   if (sub === "install") {
     const token = await loadOrCreateToken(undefined);
+
+    // Re-running install rolls a stale daemon forward: reuse the args it was
+    // started with (so a bare `ay serve install` stays "the same daemon"), unless
+    // new args are given. The persisted room + token mean the share link is
+    // unchanged across the restart.
+    const priorArgs = await readDaemonServeArgs(oxmgrBin);
+    const effArgs = args.length ? args : (priorArgs ?? []);
+    const current = getInstalledPackage().version;
+
+    if (priorArgs !== null) {
+      // A daemon already exists — only disturb it if it's actually outdated.
+      const runningVer = await fetchDaemonVersion(portFromArgs(effArgs), token);
+      if (runningVer === current) {
+        await ensureBootAutostart(oxmgrBin);
+        process.stdout.write(`'${DAEMON_NAME}' already running v${current} (up to date)\n`);
+        return 0;
+      }
+      // Outdated (or unreachable/too-old to report) → graceful roll-forward.
+      // `oxmgr stop` sends SIGTERM, which cmdServe handles cleanly (closing share
+      // peers so browsers reconnect fast), then we re-create with the new binary.
+      process.stdout.write(
+        `rolling '${DAEMON_NAME}' ${runningVer ? `v${runningVer}` : "(unknown)"} → v${current}…\n`,
+      );
+      await spawnExit([oxmgrBin, "stop", DAEMON_NAME]);
+      await spawnExit([oxmgrBin, "delete", DAEMON_NAME]);
+    }
+
     // Build the ay serve command with forwarded args (port, host, --webrtc, etc.).
     // Absolute paths: oxmgr's daemon environment may not have ~/.bun/bin in
     // PATH, so a bare `ay` (or its `#!/usr/bin/env bun` shebang) fails to spawn.
     const ayBin = Bun.which("ay");
-    const serveCmd = [...(ayBin ? [process.execPath, ayBin] : ["ay"]), "serve", ...args].join(" ");
+    const serveCmd = [...(ayBin ? [process.execPath, ayBin] : ["ay"]), "serve", ...effArgs].join(
+      " ",
+    );
     const proc = Bun.spawn(
       [oxmgrBin, "start", serveCmd, "--name", DAEMON_NAME, "--restart", "always"],
       { stdio: ["ignore", "inherit", "inherit"] },
     );
     const code = await proc.exited;
     if (code === 0) {
-      const portM = /--port[=\s](\d+)/.exec(args.join(" "));
-      const port = portM ? Number(portM[1]) : DEFAULT_PORT;
+      const onBoot = await ensureBootAutostart(oxmgrBin);
+      const port = portFromArgs(effArgs);
       // Mirror cmdServe's mode resolution: webrtc-only daemons open no HTTP port.
-      const webrtcish = args.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
+      const webrtcish = effArgs.some((a) => a.startsWith("--webrtc") || a.startsWith("--share"));
       const httpish =
-        args.some((a) => a.startsWith("--http") || a.startsWith("--share")) ||
-        !args.some((a) => a.startsWith("--webrtc"));
-      process.stdout.write(`\ninstalled '${DAEMON_NAME}' as a daemon via oxmgr\n`);
+        effArgs.some((a) => a.startsWith("--http") || a.startsWith("--share")) ||
+        !effArgs.some((a) => a.startsWith("--webrtc"));
+      process.stdout.write(
+        `\n${priorArgs !== null ? `rolled '${DAEMON_NAME}' forward to` : `installed '${DAEMON_NAME}' as a daemon via oxmgr —`} v${current}\n`,
+      );
+      process.stdout.write(
+        onBoot
+          ? `start-on-boot: enabled (oxmgr registered with the system init)\n`
+          : `start-on-boot: not registered — run \`oxmgr service install\` to enable\n`,
+      );
       process.stdout.write(`token: ${token}\n\n`);
       if (httpish) {
         process.stdout.write(`  ay ls   ${token}@<host>:${port}\n`);
@@ -486,6 +615,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
       return Response.json({ host: user ? `${user}@${host}` : host });
     }
 
+    // GET /api/version — the running daemon's package version, so a re-run of
+    // `ay serve install` can tell whether the live daemon is stale and roll it
+    // forward. A daemon too old to expose this just 404s → treated as outdated.
+    if (req.method === "GET" && p === "/api/version") {
+      return Response.json({ version: getInstalledPackage().version });
+    }
+
     // GET /api/notes
     if (req.method === "GET" && p === "/api/notes") {
       const notes = await readNotes();
@@ -751,6 +887,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
       try {
         const child = Bun.spawn(["ay", cli, ...(prompt ? ["--", prompt] : [])], {
           cwd,
+          env: freshAgentEnv(), // don't leak our Claude Code session into the agent
           stdin: "ignore",
           stdout: "ignore",
           stderr: "ignore",

package/dist/SUPPORTED_CLIS-DF0iApn5.js

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