claude-yes 1.153.2 → 1.154.0

package/dist/{subcommands-CapfwHNa.js → subcommands-C4tMi9NX.js}

@@ -1,9 +1,9 @@
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-DlmmJlO8.js";
-import { t as loadSharedCliDefaults } from "./configShared-C1C04bbq.js";
-import { n as isWebrtcSpec } from "./webrtcLink-BWhuA74k.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-qK6uozO4.js";
+import { t as loadSharedCliDefaults } from "./configShared-CEyhl0WH.js";
+import { n as isWebrtcSpec } from "./webrtcLink-CBZkZ-LT.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-DBCvpp3B.js";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, stat, writeFile } from "fs/promises";
@@ -554,19 +554,19 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-CoUlCHxT.js");
+				const { cmdServe } = await import("./serve-BYc2J-2F.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-CSgScgPD.js");
+				const { cmdSetup } = await import("./setup-D9emVJYz.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-Bxei036B.js");
+				const { cmdSchedule } = await import("./schedule-BPFBe7R5.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-5lHLAAqn.js");
+				const { cmdRemote } = await import("./remotes-DkNuq417.js");
 				return cmdRemote(rest);
 			}
 			case "reap":
@@ -583,7 +583,7 @@ async function runSubcommand(argv) {
 }
 function cmdHelp(managerCommands = true) {
 	const setupLine = managerCommands ? `  ay setup                            guided setup: pick a workspace, share to agent-yes.com\n` : ``;
-	process.stdout.write("ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
+	process.stdout.write("ay - agent-yes CLI\n\nManagement:\n  ay ls [keyword]                     list running agents\n  ay tail [-f] [-n N] <keyword>       last N lines (96), -f to follow\n  ay read <keyword> [page opts]       paginate: --last/--head N, --range A:B,\n                                        --before-line L [--limit N]\n  ay cat <keyword>                    full log\n  ay head <keyword>                   first N lines\n  ay send <keyword> <msg>             send a message\n  ay attach <keyword>                 interactive attach (detach: Ctrl-\\)\n  ay stop <keyword>                   graceful shutdown (/exit for claude/codex)\n  ay exit <keyword> [reason]          graceful shutdown, recording who/why (= 'ay send <kw> exit')\n  ay restart <keyword> [--fresh]      stop (if live) + relaunch resuming the session; --fresh replays the prompt\n  ay status <keyword>                 agent status snapshot\n  ay result <keyword> [--wait]        pull an agent's structured result envelope\n  ay result set '<json>'              (inside an agent) deposit your result envelope\n  ay reap                             kill process groups leaked by dead agents\n\nRemote:\n" + setupLine + "  ay schedule <when> <cli> -- <msg>   run an agent on a schedule (HH:MM or cron)\n  ay serve [--port N]                 start HTTP API server (prints token)\n  ay serve status                     show serve daemon/server status\n  ay remote add <alias> http://<token>@<host>:<port>\n  ay remote ls / rm <alias>           manage saved remotes\n  ay ls   <token>@<host>:<port>       connect inline (no alias needed)\n  ay send <token>@<host>:<port>:<kw> <msg>\n\nRun an agent:\n  ay [claude|codex|gemini|...] [options] -- [prompt]\n  ay claude -- \"fix the bug in auth.ts\"\n  ay claude --help                    full agent-runner options\n\nLabs (examples at https://github.com/snomiao/agent-yes/tree/main/lab):\n  local-role-play/   designer + builder on one machine\n  http-remote/       ay serve remote access demo\n  p2p-pairing/       libp2p P2P  (needs: cargo build --features swarm)\n");
 	return 0;
 }
 function matchKeyword(record, keyword) {
@@ -899,7 +899,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-jGM3ZHK3.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-Ccdzmuc-.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -1002,6 +1002,10 @@ async function deriveLiveState(r) {
 		state: "stopped",
 		question: null
 	};
+	if (r.unresponsive) return {
+		state: "stuck",
+		question: null
+	};
 	if (r.log_file) {
 		const ni = await extractNeedsInput(r.log_file, r.cli);
 		if (ni) return {
@@ -2283,14 +2287,74 @@ async function cmdAttach(rest) {
 	});
 	return 0;
 }
+/**
+* Decide how to relaunch an agent on `ay restart`. Pure (no I/O) so it's unit
+* testable. Precedence:
+*  - `fresh`: replay the original prompt (the old behaviour), no resume.
+*  - else if the CLI printed a resume command its `resumeCommand` regex matches
+*    in the captured log (capture group 1 = the arg string), relaunch with those
+*    whitespace-split args.
+*  - else fall back to `restoreArgs` (e.g. `--continue`) so the wrapper's own
+*    resume plumbing (claude --continue, codex stored-session) kicks in.
+*/
+function resolveResumeArgs(conf, logText, opts) {
+	if (opts.fresh) return opts.prompt ? {
+		args: [opts.prompt],
+		strategy: "fresh (replay original prompt)"
+	} : {
+		args: [],
+		strategy: "fresh (no prompt)"
+	};
+	const re = conf?.resumeCommand;
+	if (re) {
+		const captured = (re.global ? new RegExp(re.source, re.flags.replace(/g/g, "")) : re).exec(logText)?.[1]?.trim();
+		if (captured) {
+			const parts = captured.split(/\s+/).filter(Boolean);
+			if (parts.length) return {
+				args: parts,
+				strategy: `printed resume command: ${captured}`
+			};
+		}
+	}
+	const restore = conf?.restoreArgs;
+	if (restore && restore.length) return {
+		args: [...restore],
+		strategy: `restoreArgs (${restore.join(" ")})`
+	};
+	return {
+		args: ["--continue"],
+		strategy: "--continue (fallback)"
+	};
+}
+/**
+* Wait for a pid to exit. No cross-process exit event exists (the agent is owned
+* by its own wrapper), so poll `isPidAlive` — checked once immediately, then with
+* golden-ratio backoff (1.0, 1.6, 2.6…s, capped) up to `timeoutMs`. Returns true
+* once the pid is gone.
+*/
+async function waitForExit(pid, timeoutMs) {
+	if (!isPidAlive(pid)) return true;
+	const start = Date.now();
+	let delay = 1e3;
+	while (Date.now() - start < timeoutMs) {
+		await new Promise((r) => setTimeout(r, delay));
+		if (!isPidAlive(pid)) return true;
+		delay = Math.min(Math.round(delay * 1.618), 8e3);
+	}
+	return !isPidAlive(pid);
+}
 async function cmdRestart(rest) {
-	const argv = await yargs(rest).usage("Usage: ay restart <keyword>").option("latest", {
+	const argv = await yargs(rest).usage("Usage: ay restart <keyword> [--fresh]").option("latest", {
 		type: "boolean",
 		default: false,
 		description: "Use most recent match"
 	}).option("cwd", {
 		type: "string",
 		description: "Restrict to agents under this dir"
+	}).option("fresh", {
+		type: "boolean",
+		default: false,
+		description: "Replay the original prompt instead of resuming the session"
 	}).help(false).version(false).exitProcess(false).parseAsync();
 	const opts = {
 		all: true,
@@ -2300,13 +2364,32 @@ async function cmdRestart(rest) {
 		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	};
 	const record = await resolveOne(argv._[0] !== void 0 ? String(argv._[0]) : void 0, opts);
+	const fresh = Boolean(argv.fresh);
 	if (isPidAlive(record.pid)) {
-		process.stderr.write(`pid ${record.pid} is still running — stop it first or use ay send\n`);
-		return 1;
+		await gracefulExitAgent(record, "restart");
+		process.stdout.write(`stopping pid ${record.pid} (${record.cli}) before restart…\n`);
+		let exited = await waitForExit(record.pid, 3e4);
+		if (!exited) {
+			try {
+				process.kill(record.pid, "SIGKILL");
+			} catch {}
+			exited = await waitForExit(record.pid, 5e3);
+		}
+		if (!exited) {
+			process.stderr.write(`pid ${record.pid} did not exit — aborting restart (try: ay stop ${record.pid} --method=double-ctrl-c)\n`);
+			return 1;
+		}
 	}
-	const args = ["--cli=" + record.cli];
-	if (record.prompt) args.push(record.prompt);
-	const proc = Bun.spawn(["agent-yes", ...args], {
+	const conf = (await cliDefaults())[record.cli];
+	const { args: resumeArgs, strategy } = resolveResumeArgs(conf, !fresh && record.log_file ? await readFile(record.log_file, "utf8").catch(() => "") : "", {
+		fresh,
+		prompt: record.prompt
+	});
+	const proc = Bun.spawn([
+		"agent-yes",
+		"--cli=" + record.cli,
+		...resumeArgs
+	], {
 		cwd: record.cwd,
 		detached: true,
 		stdio: [
@@ -2315,7 +2398,7 @@ async function cmdRestart(rest) {
 			"ignore"
 		]
 	});
-	process.stdout.write(`restarted ${record.cli} in ${shortenPath(record.cwd)} (new pid: ${proc.pid})\n`);
+	process.stdout.write(`restarted ${record.cli} in ${shortenPath(record.cwd)} via ${strategy} (new pid: ${proc.pid})\n`);
 	process.stderr.write(`\n  ay tail ${proc.pid}   # watch output\n  ay ls                 # list all agents\n`);
 	return 0;
 }
@@ -2360,6 +2443,7 @@ async function snapshotStatus(record) {
 			question = ni.question;
 		} else if (state === "idle" && await isAgentStuck(record, logMtimeMs)) state = "stuck";
 	}
+	if (alive && record.unresponsive) state = "stuck";
 	const note = (await readNotes()).get(record.pid) ?? null;
 	return {
 		pid: record.pid,
@@ -2625,5 +2709,5 @@ async function cmdResultSet(rest) {
 }
 
 //#endregion
-export { snapshotStatus as C, runSubcommand as S, writeToIpc as T, readPtysize as _, cursorAbs as a, resolveOne as b, extractTaskCounts as c, isExitRequest as d, isPidAlive as f, readNotes as g, matchKeyword as h, controlCodeFromName as i, finalizedLines as l, listRecords as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isSubcommand as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isAgentStuck as u, renderRawLog as v, stopTipForCli as w, resolveReadWindow as x, renderRawLogLines as y };
-//# sourceMappingURL=subcommands-CapfwHNa.js.map
+export { runSubcommand as C, writeToIpc as E, resolveResumeArgs as S, stopTipForCli as T, readPtysize as _, cursorAbs as a, resolveOne as b, extractTaskCounts as c, isExitRequest as d, isPidAlive as f, readNotes as g, matchKeyword as h, controlCodeFromName as i, finalizedLines as l, listRecords as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isSubcommand as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isAgentStuck as u, renderRawLog as v, snapshotStatus as w, resolveReadWindow as x, renderRawLogLines as y };
+//# sourceMappingURL=subcommands-C4tMi9NX.js.map

package/dist/subcommands-DLvC6kto.js

@@ -0,0 +1,9 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import "./configShared-CEyhl0WH.js";
+import "./e2e-Bfw7qL9O.js";
+import "./webrtcLink-CBZkZ-LT.js";
+import "./remotes-DBCvpp3B.js";
+import { C as runSubcommand, E as writeToIpc, S as resolveResumeArgs, T as stopTipForCli, _ as readPtysize, a as cursorAbs, b as resolveOne, c as extractTaskCounts, d as isExitRequest, f as isPidAlive, g as readNotes, h as matchKeyword, i as controlCodeFromName, l as finalizedLines, m as listRecords, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isSubcommand, r as cmdHelp, s as extractNeedsInput, t as GRACEFUL_EXIT_COMMANDS, u as isAgentStuck, v as renderRawLog, w as snapshotStatus, x as resolveReadWindow, y as renderRawLogLines } from "./subcommands-C4tMi9NX.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-5Hezw9uj.js → tray-BMzpUSfa.js}

@@ -187,4 +187,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-5Hezw9uj.js.map
+//# sourceMappingURL=tray-BMzpUSfa.js.map

package/dist/{ts-C4ZmPc5P.js → ts-U3AE4u72.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-CqRHax_g.js";
+import { r as getInstalledPackage } from "./versionChecker-B-ToHoJ2.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-V4qvXgAw.js";
 import { t as PidStore } from "./pidStore-fqXqTKkh.js";
@@ -1060,7 +1060,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-BKtCmmy9.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-Bl08kMpl.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1802,4 +1802,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-C4ZmPc5P.js.map
+//# sourceMappingURL=ts-U3AE4u72.js.map

package/dist/{versionChecker-CqRHax_g.js → versionChecker-B-ToHoJ2.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "claude-yes";
-var version = "1.153.2";
+var version = "1.154.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-CqRHax_g.js.map
+//# sourceMappingURL=versionChecker-B-ToHoJ2.js.map

package/dist/{webrtcLink-BWhuA74k.js → webrtcLink-CBZkZ-LT.js}

@@ -1,4 +1,4 @@
-import { u as parseSecret } from "./e2e-ClOI_aqV.js";
+import { u as parseSecret } from "./e2e-Bfw7qL9O.js";
 
 //#region ts/webrtcLink.ts
 const SIGNAL_SUBPROTOCOL = "ay-signal-1";
@@ -42,4 +42,4 @@ function isWebrtcSpec(spec) {
 
 //#endregion
 export { isWebrtcSpec as n, parseWebrtcLink as r, SIGNAL_SUBPROTOCOL as t };
-//# sourceMappingURL=webrtcLink-BWhuA74k.js.map
+//# sourceMappingURL=webrtcLink-CBZkZ-LT.js.map

package/dist/{webrtcRemote-jGM3ZHK3.js → webrtcRemote-Ccdzmuc-.js}

@@ -1,5 +1,5 @@
-import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-ClOI_aqV.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-BWhuA74k.js";
+import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-Bfw7qL9O.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-CBZkZ-LT.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/webrtcRemote.ts
@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-jGM3ZHK3.js.map
+//# sourceMappingURL=webrtcRemote-Ccdzmuc-.js.map

package/dist/{workspaceConfig-B9VX8tVO.js → workspaceConfig-DT3cCBZK.js}

@@ -88,4 +88,4 @@ function resolveSpawnCwd(input) {
 
 //#endregion
 export { setWorkspaceRoot as a, resolveSpawnCwd as i, getWorkspaceRoot as n, isProvisionAllowed as r, getProvisionRoot as t };
-//# sourceMappingURL=workspaceConfig-B9VX8tVO.js.map
+//# sourceMappingURL=workspaceConfig-DT3cCBZK.js.map

package/lab/ui/index.html

@@ -1332,7 +1332,7 @@
             <span class="mag">⌕</span>
             <input
               id="q"
-              placeholder="filter…  repo:agent-yes  claude  symval  (space = AND)"
+              placeholder="filter…  repo:agent-yes  claude  (space = AND)"
               autocomplete="off"
               autofocus
             />

package/package.json

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

package/ts/buildRustArgs.spec.ts

@@ -167,7 +167,11 @@ describe("buildRustArgs", () => {
     });
 
     it("does not treat a supported-CLI word after -- as the CLI selector", () => {
-      const result = buildRustArgs(argv("--cwd", "/tmp/x", "--", "ask", "claude"), "claude", SUPPORTED_CLIS);
+      const result = buildRustArgs(
+        argv("--cwd", "/tmp/x", "--", "ask", "claude"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
       expect(result).toEqual(["--cli=claude", "--cwd", "/tmp/x", "--", "ask", "claude"]);
     });
   });

package/ts/configShared.ts

@@ -19,6 +19,7 @@ type RawCliConfig = Omit<
   | "exitCommands"
   | "autoRetry"
   | "needsInput"
+  | "resumeCommand"
 > & {
   ready?: RegexSource[];
   fatal?: RegexSource[];
@@ -30,6 +31,7 @@ type RawCliConfig = Omit<
   updateAvailable?: RegexSource[];
   autoRetry?: RegexSource[];
   needsInput?: RegexSource[];
+  resumeCommand?: RegexSource;
   exitCommands?: string[];
   exitCommand?: string[];
 };
@@ -84,6 +86,7 @@ export function normalizeCliConfig(raw: RawCliConfig): AgentCliConfig {
     updateAvailable,
     autoRetry,
     needsInput,
+    resumeCommand,
     exitCommands,
     exitCommand,
     ...rest
@@ -101,6 +104,7 @@ export function normalizeCliConfig(raw: RawCliConfig): AgentCliConfig {
     updateAvailable: compileRegexList(updateAvailable),
     autoRetry: compileRegexList(autoRetry),
     needsInput: compileRegexList(needsInput),
+    resumeCommand: resumeCommand === undefined ? undefined : compileRegexSource(resumeCommand),
     exitCommands: exitCommands ?? exitCommand,
   };
 }

package/ts/globalPidIndex.ts

@@ -33,6 +33,11 @@ export interface GlobalPidRecord {
   log_file: string | null;
   fifo_file?: string | null;
   status: "active" | "idle" | "exited";
+  // Set by the Rust supervisor when the agent produced no PTY output after a
+  // high-signal poke / while a "working" spinner is frozen — i.e. it looks
+  // wedged. Orthogonal to `status` (which stays "active"); cleared on recovery
+  // and on exit. The ls/status live-state derivation surfaces it as `stuck`.
+  unresponsive?: boolean;
   exit_code: number | null;
   exit_reason: string | null;
   started_at: number;

package/ts/index.ts

@@ -75,6 +75,7 @@ export type AgentCliConfig = {
   // crash/resuming-session behaviour
   restoreArgs?: string[]; // arguments to continue the session when crashed
   restartWithoutContinueArg?: RegExp[]; // array of regex to match for errors that require restart without continue args
+  resumeCommand?: RegExp; // optional: scraped from the agent's log on `ay restart`. Capture group 1 is the argument string (whitespace-split) to relaunch with — i.e. a resume command the CLI printed, like "--resume <id>". When absent or unmatched, restart falls back to restoreArgs (e.g. --continue).
 };
 export type AgentYesConfig = {
   configDir?: string; // directory to store agent-yes config files, e.g. session store

package/ts/openBrowser.spec.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+const spawn = vi.fn();
+const createInterface = vi.fn();
+vi.mock("node:child_process", () => ({ spawn: (...a: unknown[]) => spawn(...a) }));
+vi.mock("node:readline", () => ({
+  createInterface: (...a: unknown[]) => createInterface(...a),
+}));
+
+import { resolveOpener, openInBrowser, offerOpenInBrowser } from "./openBrowser.ts";
+
+const URL = "https://agent-yes.com/w/#room:tok";
+
+// A fake child whose .on()/.unref() are inert — enough for openInBrowser's
+// fire-and-forget launch.
+const fakeChild = () => ({ on: vi.fn(), unref: vi.fn() });
+// A fake readline that answers `reply` to the next question() call.
+const fakeRl = (reply: string) => ({
+  question: (_q: string, cb: (a: string) => void) => cb(reply),
+  close: vi.fn(),
+});
+
+// Force a resolvable opener regardless of the host platform: on Linux runners
+// (incl. headless CI) resolveOpener needs a display, so pin one. macOS/Windows
+// resolve an opener anyway, so this is harmless there.
+let savedDisplay: string | undefined;
+beforeEach(() => {
+  spawn.mockReset();
+  createInterface.mockReset();
+  savedDisplay = process.env.DISPLAY;
+  process.env.DISPLAY = ":99";
+});
+afterEach(() => {
+  if (savedDisplay === undefined) delete process.env.DISPLAY;
+  else process.env.DISPLAY = savedDisplay;
+});
+
+// resolveOpener is the pure resolution table — the only branching worth pinning.
+describe("resolveOpener", () => {
+  it("uses `open` on macOS", () => {
+    expect(resolveOpener(URL, "darwin", {})).toEqual({ cmd: "open", args: [URL] });
+  });
+
+  it("uses cmd /c start with an empty title arg on Windows", () => {
+    expect(resolveOpener(URL, "win32", {})).toEqual({
+      cmd: "cmd",
+      args: ["/c", "start", "", URL],
+    });
+  });
+
+  it("uses xdg-open on Linux when a display is present (X11 or Wayland)", () => {
+    expect(resolveOpener(URL, "linux", { DISPLAY: ":0" })).toEqual({
+      cmd: "xdg-open",
+      args: [URL],
+    });
+    expect(resolveOpener(URL, "linux", { WAYLAND_DISPLAY: "wayland-0" })).toEqual({
+      cmd: "xdg-open",
+      args: [URL],
+    });
+  });
+
+  it("returns null on a headless Linux box (no display → nothing to open)", () => {
+    expect(resolveOpener(URL, "linux", {})).toBeNull();
+  });
+});
+
+describe("openInBrowser", () => {
+  it("spawns the platform opener detached and returns true when one exists", () => {
+    spawn.mockReturnValue(fakeChild());
+    expect(openInBrowser(URL)).toBe(true);
+    expect(spawn).toHaveBeenCalledOnce();
+  });
+
+  it("returns false (and never spawns) when spawn throws", () => {
+    spawn.mockImplementation(() => {
+      throw new Error("ENOENT");
+    });
+    expect(openInBrowser(URL)).toBe(false);
+  });
+});
+
+describe("offerOpenInBrowser", () => {
+  const withTTY = async (fn: () => Promise<void>) => {
+    const [si, so] = [process.stdin.isTTY, process.stdout.isTTY];
+    process.stdin.isTTY = true;
+    process.stdout.isTTY = true;
+    try {
+      await fn();
+    } finally {
+      process.stdin.isTTY = si;
+      process.stdout.isTTY = so;
+    }
+  };
+
+  it("no-ops without prompting when stdin is not a TTY (curl|sh / CI / daemon)", async () => {
+    const orig = process.stdin.isTTY;
+    process.stdin.isTTY = false;
+    try {
+      expect(await offerOpenInBrowser(URL)).toBe(false);
+      expect(createInterface).not.toHaveBeenCalled();
+    } finally {
+      process.stdin.isTTY = orig;
+    }
+  });
+
+  it("opens on an empty answer (default yes)", async () => {
+    await withTTY(async () => {
+      createInterface.mockReturnValue(fakeRl(""));
+      spawn.mockReturnValue(fakeChild());
+      expect(await offerOpenInBrowser(URL)).toBe(true);
+      expect(spawn).toHaveBeenCalledOnce();
+    });
+  });
+
+  it("opens on an explicit yes", async () => {
+    await withTTY(async () => {
+      createInterface.mockReturnValue(fakeRl("Y"));
+      spawn.mockReturnValue(fakeChild());
+      expect(await offerOpenInBrowser(URL)).toBe(true);
+    });
+  });
+
+  it("does not open when the operator declines", async () => {
+    await withTTY(async () => {
+      createInterface.mockReturnValue(fakeRl("n"));
+      expect(await offerOpenInBrowser(URL)).toBe(false);
+      expect(spawn).not.toHaveBeenCalled();
+    });
+  });
+});

package/ts/openBrowser.ts

@@ -0,0 +1,67 @@
+// Open a URL in the operator's default browser, gated behind an interactive
+// prompt. Used after `ay serve --share` prints a WebRTC console link so the
+// operator can jump straight into the console — but only when there's a real
+// terminal to ask on AND a graphical session to open into, so SSH/CI/daemon
+// runs never try to launch a browser they can't show (they just print the link).
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+
+/**
+ * The platform command that opens `url` in the default browser, or null when we
+ * have no way to (a headless Linux box with no display). Pure — platform/env are
+ * injectable so the resolution table is unit-testable.
+ */
+export function resolveOpener(
+  url: string,
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+): { cmd: string; args: string[] } | null {
+  if (platform === "darwin") return { cmd: "open", args: [url] };
+  // `start` is a cmd builtin; the empty "" is its title arg so a URL with spaces
+  // isn't mistaken for the window title.
+  if (platform === "win32") return { cmd: "cmd", args: ["/c", "start", "", url] };
+  // Linux/BSD: opening a browser only makes sense inside a graphical session.
+  if (!env.DISPLAY && !env.WAYLAND_DISPLAY) return null;
+  return { cmd: "xdg-open", args: [url] };
+}
+
+/** Fire-and-forget launch of the browser. Returns false when we can't open. */
+export function openInBrowser(url: string): boolean {
+  const opener = resolveOpener(url);
+  if (!opener) return false;
+  try {
+    const child = spawn(opener.cmd, opener.args, { stdio: "ignore", detached: true });
+    child.on("error", () => {}); // missing opener binary → swallow, never crash the caller
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Offer to open `url` in the browser, defaulting to yes. No-ops silently unless
+ * BOTH stdin/stdout are a TTY (so we can ask) AND a browser opener exists for
+ * this platform (so "yes" can actually do something). Non-interactive contexts
+ * — `curl | sh`, SSH, CI, the daemon — fall through and just leave the link
+ * printed, as the operator chose.
+ */
+export async function offerOpenInBrowser(
+  url: string,
+  prompt = "Open in browser now? [Y/n] ",
+): Promise<boolean> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return false;
+  if (!resolveOpener(url)) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (
+      await new Promise<string>((resolve) => rl.question(prompt, resolve))
+    )
+      .trim()
+      .toLowerCase();
+    if (answer !== "" && answer !== "y" && answer !== "yes") return false;
+  } finally {
+    rl.close();
+  }
+  return openInBrowser(url);
+}

package/ts/serve.ts

@@ -388,9 +388,9 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
         /* best effort — fall back to the .share-link file hint in emitShareLink */
       }
     }
-    const emitShareLink = () => {
+    const emitShareLink = async () => {
       if (!webrtcDaemon) return;
-      if (shareLink)
+      if (shareLink) {
         process.stdout.write(
           `\nshared over WebRTC — open this link (the token is eaten from the URL on open):\n` +
             `  ${shareLink}\n` +
@@ -398,7 +398,11 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
               ? `  (persistent room — same link across restarts; delete ~/.agent-yes/.share-room to rotate)\n`
               : ``),
         );
-      else
+        // Offer to jump straight into the console (default yes); no-ops on a
+        // non-TTY or headless box, leaving the link printed above.
+        const { offerOpenInBrowser } = await import("./openBrowser.ts");
+        await offerOpenInBrowser(shareLink);
+      } else
         process.stdout.write(
           `\nthe WebRTC share link carries a secret, so the daemon does NOT log it —\n` +
             `read it from ~/.agent-yes/.share-link (mode 0600). The room persists in\n` +
@@ -418,7 +422,7 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       if (runningVer === current && sameConfig) {
         await ensureBootAutostart(mgr);
         process.stdout.write(`'${DAEMON_NAME}' already running v${current} (up to date)\n`);
-        emitShareLink();
+        await emitShareLink();
         return 0;
       }
       // Outdated, unreachable, or reconfigured → graceful roll-forward. `stop` sends
@@ -528,7 +532,7 @@ async function cmdServeDaemon(sub: string, args: string[]): Promise<number> {
       }
       process.stdout.write(`  ay serve logs                # view server logs\n`);
       process.stdout.write(`  ay serve uninstall           # remove daemon\n`);
-      emitShareLink();
+      await emitShareLink();
     }
     return code ?? 1;
   }
@@ -983,7 +987,10 @@ export async function cmdServe(rest: string[]): Promise<number> {
     const status = await deriveLiveStatus(r);
     return {
       ...r,
-      status,
+      // The Rust supervisor's unresponsive flag is an authoritative wedge signal —
+      // surface it as `stuck` so the console's dot matches `ay ls`. (A dead agent
+      // is never unresponsive — Rust clears the flag on exit.)
+      status: status !== "exited" && r.unresponsive ? "stuck" : status,
       title: await logTitle(r.log_file),
       git: status === "exited" ? null : await gitStatus(r.cwd),
       // Task progress from the rendered todo block (null when none detected → no
@@ -1770,6 +1777,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
             ? "\n"
             : `  (persistent room — same link across restarts; delete ~/.agent-yes/.share-room to rotate)\n\n`;
           process.stdout.write(`${wantHttp ? "\n" : ""}${lead}:\n  ${link}\n` + persistNote);
+          // Offer to open the console (default yes) on the FIRST share only —
+          // an auto-rotation shouldn't pop a fresh tab from under the operator.
+          if (!rotated) {
+            const { offerOpenInBrowser } = await import("./openBrowser.ts");
+            await offerOpenInBrowser(link);
+          }
         } else {
           // Non-TTY (daemon/journal/CI): the link embeds the room secret S, so never
           // write it to a log stream. Stash it in a 0600 file and point there instead.