agent-yes 1.115.0 → 1.116.0

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

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

package/dist/SUPPORTED_CLIS-vFwB3bnK.js

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

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

@@ -1,11 +1,11 @@
-import "./ts-B62nAAfY.js";
+import "./ts-DvnOmOAf.js";
 import "./logger-B9h0djqx.js";
-import "./versionChecker-BdkE7S2A.js";
+import { r as getInstalledPackage } from "./versionChecker-DeXuTfJ0.js";
 import "./pidStore-DBjlqzo8.js";
 import "./globalPidIndex-yVd3mbsV.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-VayLM5qX.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DuCEAzP9.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-t1uOb17r.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-DLJqD_Yj.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -52,6 +52,68 @@ const defaultOpts = (overrides = {}) => ({
 	...overrides
 });
 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 +122,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 +164,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 +457,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));
@@ -687,4 +773,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-CP61tKuJ.js.map
+//# sourceMappingURL=serve-CSupgu7Q.js.map

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

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

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

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-BdkE7S2A.js";
+import { r as getInstalledPackage } from "./versionChecker-DeXuTfJ0.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";
@@ -10,7 +10,7 @@ import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path, { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { execaCommandSync, parseCommandString } from "execa";
+import { execaCommandSync, execaSync, parseCommandString } from "execa";
 import { fromReadable, fromWritable } from "from-node-stream";
 import DIE from "phpdie";
 import sflow from "sflow";
@@ -378,11 +378,10 @@ async function createLinuxFifo(cli, customPath) {
 			logger.warn(`[${cli}-yes] Failed to create FIFO directory: ${dirError}`);
 			return null;
 		}
-		const escapedPath = fifoPath.replace(/'/g, "'\"'\"'");
-		const mkfifoResult = execaCommandSync(`mkfifo '${escapedPath}'`, { reject: false });
+		const mkfifoResult = execaSync("mkfifo", [fifoPath], { reject: false });
 		if (mkfifoResult.exitCode !== 0) {
 			logger.warn(`[${cli}-yes] mkfifo command failed with exit code ${mkfifoResult.exitCode}`);
-			logger.warn(`[${cli}-yes] Command: mkfifo '${escapedPath}'`);
+			logger.warn(`[${cli}-yes] Command: mkfifo ${fifoPath}`);
 			if (mkfifoResult.stderr) logger.warn(`[${cli}-yes] mkfifo stderr: ${mkfifoResult.stderr}`);
 			if (mkfifoResult.stdout) logger.warn(`[${cli}-yes] mkfifo stdout: ${mkfifoResult.stdout}`);
 			return null;
@@ -1714,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-B62nAAfY.js.map
+//# sourceMappingURL=ts-DvnOmOAf.js.map

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

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

package/lab/ui/index.html

@@ -1618,10 +1618,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 +1643,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.115.0",
+  "version": "1.116.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;
 
@@ -70,6 +71,71 @@ const defaultOpts = (overrides: Partial<CommonOpts> = {}): CommonOpts => ({
 
 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 +149,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 +588,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();

package/dist/SUPPORTED_CLIS-DUVB1HyL.js

@@ -1,8 +0,0 @@
-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 };