agent-yes 1.153.3 → 1.154.1

package/ts/subcommands.spec.ts

@@ -1019,6 +1019,33 @@ describe("subcommands.cmdLs --all / --active / keyword filter / aliases", () =>
     expect(parsed.some((r: any) => r.prompt === "exited agent")).toBe(true);
   });
 
+  it("--json surfaces the Rust unresponsive flag as state 'stuck'", async () => {
+    const mod = await loadModule();
+    const { appendGlobalPid } = await import("./globalPidIndex.ts");
+    await appendGlobalPid({
+      pid: process.pid, // alive → not "stopped"
+      cli: "claude",
+      prompt: "wedged-agent-probe",
+      cwd: process.cwd(),
+      log_file: null,
+      status: "active",
+      unresponsive: true,
+      exit_code: null,
+      exit_reason: null,
+      started_at: Date.now(),
+    });
+    const cap = captureOutput();
+    let code: number | null;
+    try {
+      code = await mod.runSubcommand(["bun", "cli.js", "ls", "--json"]);
+    } finally {
+      cap.restore();
+    }
+    expect(code).toBe(0);
+    const row = JSON.parse(cap.stdout).find((r: any) => r.prompt === "wedged-agent-probe");
+    expect(row?.state).toBe("stuck");
+  });
+
   it("keyword filter restricts results to matching agents", async () => {
     const mod = await loadModule();
     const { appendGlobalPid } = await import("./globalPidIndex.ts");
@@ -1458,7 +1485,10 @@ describe("subcommands.cmdStatus", () => {
 // ---------------------------------------------------------------------------
 
 describe("subcommands.cmdRestart", () => {
-  it("returns 1 and warns when the agent is still alive", async () => {
+  // A live agent is now stopped-then-resumed. With no fifo_file the graceful
+  // stop can't be sent, so it errors out *before* any kill — which also proves
+  // the live test process (used as the fake pid) is never signalled.
+  it("returns 1 when a live agent can't be gracefully stopped (no fifo_file)", async () => {
     const mod = await loadModule();
     const { appendGlobalPid } = await import("./globalPidIndex.ts");
     await appendGlobalPid({
@@ -1482,10 +1512,13 @@ describe("subcommands.cmdRestart", () => {
     try {
       const code = await mod.runSubcommand(["bun", "cli.js", "restart", String(process.pid)]);
       expect(code).toBe(1);
-      expect(stderr.join("")).toMatch(/still running/);
+      expect(stderr.join("")).toMatch(/no fifo_file/);
     } finally {
       process.stderr.write = origErr;
     }
+    // The live process must still be alive — restart must not have killed it.
+    // (signal 0 throws only if the pid is gone / not signalable.)
+    expect(() => process.kill(process.pid, 0)).not.toThrow();
   });
 });
 
@@ -1745,6 +1778,29 @@ describe("subcommands.isAgentStuck / stuck state", () => {
       await rm(dir, { recursive: true, force: true }).catch(() => null);
     }
   });
+
+  it("snapshotStatus: reports 'stuck' when the Rust unresponsive flag is set (no log needed)", async () => {
+    const mod = await loadModule();
+    const snap = await mod.snapshotStatus(rec({ unresponsive: true, log_file: null }));
+    expect(snap.state).toBe("stuck");
+  });
+
+  it("snapshotStatus: the unresponsive flag overrides a quiet (would-be idle) log", async () => {
+    const dir = await mkdtemp(path.join(tmpdir(), "ay-stuck-"));
+    try {
+      const log = path.join(dir, "a.log");
+      // Long-silent, no busy marker → would read as `idle`; the flag forces `stuck`.
+      await writeFile(log, "⏺ Done — all green.\r\n❯\r\n");
+      await utimes(log, tenMinAgo(), tenMinAgo());
+      const mod = await loadModule();
+      expect((await mod.snapshotStatus(rec({ log_file: log }))).state).toBe("idle");
+      expect((await mod.snapshotStatus(rec({ log_file: log, unresponsive: true }))).state).toBe(
+        "stuck",
+      );
+    } finally {
+      await rm(dir, { recursive: true, force: true }).catch(() => null);
+    }
+  });
 });
 
 // A CLI like Claude Code repaints by moving the cursor UP over the previous
@@ -1823,3 +1879,64 @@ describe("subcommands.cmdRead replays at the ptysize sidecar geometry", () => {
     }
   });
 });
+
+describe("subcommands.resolveResumeArgs", () => {
+  it("replays the original prompt when --fresh", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    expect(
+      resolveResumeArgs({ restoreArgs: ["--continue"] }, "irrelevant log", {
+        fresh: true,
+        prompt: "do the thing",
+      }),
+    ).toEqual({ args: ["do the thing"], strategy: "fresh (replay original prompt)" });
+  });
+
+  it("--fresh with no prompt yields no args", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    expect(resolveResumeArgs(undefined, "", { fresh: true })).toEqual({
+      args: [],
+      strategy: "fresh (no prompt)",
+    });
+  });
+
+  it("scrapes a printed resume command (capture group 1, whitespace-split)", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    const conf = { resumeCommand: /To resume run: agent (.+)/ };
+    const log = "...\nTo resume run: agent --resume abc-123\n> ";
+    expect(resolveResumeArgs(conf, log, { fresh: false })).toEqual({
+      args: ["--resume", "abc-123"],
+      strategy: "printed resume command: --resume abc-123",
+    });
+  });
+
+  it("ignores a stray global flag on resumeCommand and still captures", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    const conf = { resumeCommand: /resume=(\S+)/g };
+    expect(resolveResumeArgs(conf, "session resume=zzz here", { fresh: false }).args).toEqual([
+      "zzz",
+    ]);
+  });
+
+  it("falls back to restoreArgs when resumeCommand is absent or unmatched", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    expect(
+      resolveResumeArgs({ restoreArgs: ["--continue"] }, "no resume hint here", { fresh: false }),
+    ).toEqual({ args: ["--continue"], strategy: "restoreArgs (--continue)" });
+    // resumeCommand present but no match in the log → still falls back.
+    expect(
+      resolveResumeArgs(
+        { resumeCommand: /resume (\S+)/, restoreArgs: ["resume", "--last"] },
+        "nothing matches",
+        { fresh: false },
+      ).args,
+    ).toEqual(["resume", "--last"]);
+  });
+
+  it("falls back to --continue when neither resumeCommand nor restoreArgs exist", async () => {
+    const { resolveResumeArgs } = await loadModule();
+    expect(resolveResumeArgs(undefined, "", { fresh: false })).toEqual({
+      args: ["--continue"],
+      strategy: "--continue (fallback)",
+    });
+  });
+});

package/ts/subcommands.ts

@@ -392,6 +392,7 @@ export function cmdHelp(managerCommands = true): number {
       `  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` +
@@ -999,6 +1000,10 @@ async function deriveLiveState(
 ): Promise<{ state: LiveState; question: string | null }> {
   const base = await deriveLiveStatus(r);
   if (base === "exited") return { state: "stopped", question: null };
+  // The Rust supervisor flagged this agent unresponsive (no PTY output after a
+  // poke / a frozen "working" spinner) — an authoritative wedge signal, so it
+  // wins over the log-tail heuristics (needs_input / stuck) below.
+  if (r.unresponsive) return { state: "stuck", question: null };
   // A blocked menu overrides active/idle (alive + quiet, but waiting for an answer).
   if (r.log_file) {
     const ni = await extractNeedsInput(r.log_file, r.cli);
@@ -2754,11 +2759,72 @@ async function cmdAttach(rest: string[]): Promise<number> {
 // ay restart
 // ---------------------------------------------------------------------------
 
+/**
+ * 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.
+ */
+export function resolveResumeArgs(
+  conf: AgentCliConfig | undefined,
+  logText: string,
+  opts: { fresh: boolean; prompt?: string },
+): { args: string[]; strategy: string } {
+  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) {
+    // Strip a stray `g` flag so .exec returns capture groups deterministically.
+    const probe = re.global ? new RegExp(re.source, re.flags.replace(/g/g, "")) : re;
+    const m = probe.exec(logText);
+    const captured = m?.[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: number, timeoutMs: number): Promise<boolean> {
+  if (!isPidAlive(pid)) return true;
+  const start = Date.now();
+  let delay = 1000;
+  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), 8000);
+  }
+  return !isPidAlive(pid);
+}
+
 async function cmdRestart(rest: string[]): Promise<number> {
   const y = yargs(rest)
-    .usage("Usage: ay restart <keyword>")
+    .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);
@@ -2773,23 +2839,50 @@ async function cmdRestart(rest: string[]): Promise<number> {
   };
   const keyword = argv._[0] !== undefined ? String(argv._[0]) : undefined;
   const record = await resolveOne(keyword, opts);
+  const fresh = Boolean(argv.fresh);
 
+  // Live agent: gracefully stop it (claude /exit / double-Ctrl+C via FIFO), then
+  // wait for it to actually exit before relaunching.
   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, 30_000);
+    if (!exited) {
+      // Wouldn't go gracefully — SIGKILL the pid (the reaper sweeps its pgid).
+      try {
+        process.kill(record.pid, "SIGKILL");
+      } catch {
+        /* already gone / not permitted */
+      }
+      exited = await waitForExit(record.pid, 5_000);
+    }
+    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);
+  // Resolve how to relaunch: a printed resume command (config `resumeCommand`),
+  // else restoreArgs/--continue, else replay the prompt when --fresh.
+  const conf = (await cliDefaults())[record.cli];
+  const logText =
+    !fresh && record.log_file ? await readFile(record.log_file, "utf8").catch(() => "") : "";
+  const { args: resumeArgs, strategy } = resolveResumeArgs(conf, logText, {
+    fresh,
+    prompt: record.prompt,
+  });
 
-  const proc = Bun.spawn(["agent-yes", ...args], {
+  const proc = Bun.spawn(["agent-yes", "--cli=" + record.cli, ...resumeArgs], {
     cwd: record.cwd,
     detached: true,
     stdio: ["ignore", "ignore", "ignore"],
   });
 
   process.stdout.write(
-    `restarted ${record.cli} in ${shortenPath(record.cwd)} (new pid: ${proc.pid})\n`,
+    `restarted ${record.cli} in ${shortenPath(record.cwd)} via ${strategy} (new pid: ${proc.pid})\n`,
   );
   process.stderr.write(
     `\n` +
@@ -2891,6 +2984,10 @@ export async function snapshotStatus(record: GlobalPidRecord): Promise<StatusSna
       state = "stuck";
     }
   }
+  // The Rust supervisor's unresponsive flag is an authoritative wedge signal —
+  // it overrides the log-tail heuristics above (but never a dead agent, which
+  // Rust clears the flag on anyway).
+  if (alive && record.unresponsive) state = "stuck";
   const notes = await readNotes();
   const note = notes.get(record.pid) ?? null;
   return {

package/dist/SUPPORTED_CLIS-C4swzsq1.js

@@ -1,8 +0,0 @@
-import "./ts-CxC_nYZ4.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-D6lNBbCr.js";
-import "./pidStore-fqXqTKkh.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bc0HAQER.js";
-
-export { SUPPORTED_CLIS };

package/dist/subcommands-CVSvhyYN.js

@@ -1,9 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import "./configShared-C1C04bbq.js";
-import "./e2e-ClOI_aqV.js";
-import "./webrtcLink-BWhuA74k.js";
-import "./remotes-qK6uozO4.js";
-import { C as snapshotStatus, S as runSubcommand, T as writeToIpc, _ 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 stopTipForCli, x as resolveReadWindow, y as renderRawLogLines } from "./subcommands-w_qFLMDs.js";
-
-export { cmdHelp, isSubcommand, runSubcommand };