agent-yes 1.265.4 → 1.266.0

package/ts/parentPingSend.spec.ts

@@ -0,0 +1,195 @@
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { buildPingBody, buildSendArgv, deliverPing, type PingSelf } from "./parentPingSend.ts";
+import type { PingDecision } from "./parentPing.ts";
+
+const self: PingSelf = {
+  cli: "claude",
+  pid: 777,
+  cwd: "/repo",
+  prompt: "fix the flaky test",
+};
+const d = (over: Partial<PingDecision> = {}): PingDecision => ({
+  reason: "finished",
+  attempt: 1,
+  question: null,
+  ...over,
+});
+
+describe("buildPingBody", () => {
+  it("wraps in <ay-report …> with the child's identity", () => {
+    const out = buildPingBody(d(), self);
+    expect(out).toMatch(/^<ay-report from claude #777 @ \/repo>/);
+    expect(out.endsWith("</ay-report>")).toBe(true);
+  });
+
+  it("says which edge fired", () => {
+    expect(buildPingBody(d(), self)).toContain("looks FINISHED");
+    expect(buildPingBody(d({ reason: "stuck" }), self)).toContain("is STUCK");
+    expect(buildPingBody(d({ reason: "exited" }), self)).toContain("has EXITED");
+  });
+
+  it("is explicit that this is the WRAPPER talking, not the agent", () => {
+    const out = buildPingBody(d(), self);
+    expect(out).toContain("automatic report from its agent-yes wrapper");
+    expect(out).toContain("not as its answer");
+  });
+
+  it("marks a repeat as a reminder so the parent knows it already ignored one", () => {
+    expect(buildPingBody(d({ attempt: 1 }), self)).not.toContain("reminder");
+    expect(buildPingBody(d({ attempt: 3 }), self)).toContain("reminder #2 — no reply yet");
+  });
+
+  it("reminds the parent what it asked for", () => {
+    expect(buildPingBody(d(), self)).toContain("Task it was spawned with: fix the flaky test");
+    expect(buildPingBody(d(), { ...self, prompt: null })).not.toContain("Task it was spawned with");
+  });
+
+  it("carries the question for a stuck report", () => {
+    const out = buildPingBody(d({ reason: "stuck", question: "Approve edit?" }), self);
+    expect(out).toContain("It is asking: Approve edit?");
+  });
+
+  it("includes the exit code only for an exit report", () => {
+    expect(buildPingBody(d({ reason: "exited" }), { ...self, exitCode: 2 })).toContain(
+      "Exit code: 2",
+    );
+    expect(buildPingBody(d({ reason: "exited" }), { ...self, exitCode: 0 })).toContain(
+      "Exit code: 0",
+    );
+    expect(buildPingBody(d({ reason: "exited" }), { ...self, exitCode: null })).not.toContain(
+      "Exit code:",
+    );
+  });
+
+  it("attaches the tail as evidence, because the parent is not tailing", () => {
+    const out = buildPingBody(d(), self, "  \nall tests passed\n");
+    expect(out).toContain("Last output:");
+    expect(out).toContain("all tests passed");
+  });
+
+  it("omits an empty tail section entirely", () => {
+    expect(buildPingBody(d(), self, "   \n  ")).not.toContain("Last output:");
+    expect(buildPingBody(d(), self, null)).not.toContain("Last output:");
+  });
+
+  it("clips a runaway tail on a word boundary", () => {
+    const out = buildPingBody(d(), self, "word ".repeat(1000));
+    expect(out).toContain("…");
+    expect(out.length).toBeLessThan(2000);
+  });
+
+  it("offers result/cat for an exited child and tail/send for a live one", () => {
+    expect(buildPingBody(d({ reason: "exited" }), self)).toContain("ay result get 777");
+    expect(buildPingBody(d({ reason: "stuck" }), self)).toContain(`ay send 777 "..."`);
+  });
+});
+
+describe("buildSendArgv", () => {
+  it("re-invokes THIS entrypoint so the ping uses the same build", () => {
+    const { cmd, args } = buildSendArgv("agt_parent", "/opt/agent-yes/dist/agent-yes.js");
+    expect(cmd).toBe(process.execPath);
+    expect(args).toEqual([
+      "/opt/agent-yes/dist/agent-yes.js",
+      "send",
+      "agt_parent",
+      "-",
+      "--force",
+      "--no-wait",
+    ]);
+  });
+
+  it("falls back to `ay` on PATH when there is no argv[1]", () => {
+    const { cmd, args } = buildSendArgv("agt_parent");
+    expect(cmd).toBe("ay");
+    expect(args[0]).toBe("send");
+  });
+
+  it("reads the body from stdin (`-`) so a multi-line report needs no escaping", () => {
+    expect(buildSendArgv("x", "e.js").args).toContain("-");
+  });
+
+  it("forces past the recency guard and never blocks on the parent's screen", () => {
+    const { args } = buildSendArgv("x", "e.js");
+    expect(args).toContain("--force");
+    expect(args).toContain("--no-wait");
+  });
+});
+
+describe("deliverPing", () => {
+  it("resolves false instead of throwing when the command cannot be spawned", async () => {
+    const argv1 = process.argv[1];
+    process.argv[1] = "/nonexistent/definitely-not-here.js";
+    try {
+      await expect(
+        deliverPing({
+          target: "x",
+          body: "b",
+          selfWrapperPid: 1,
+          timeoutMs: 5_000,
+        }),
+      ).resolves.toBe(false);
+    } finally {
+      process.argv[1] = argv1!;
+    }
+  });
+});
+
+describe("deliverPing — the wire contract, against a stub `ay send`", () => {
+  // Exercises the real subprocess path: what argv the stub is invoked with, what
+  // arrives on its stdin, and what AGENT_YES_PID it inherits. That last one is
+  // the subtle bug this guards: the wrapper's own AGENT_YES_PID is the PARENT's
+  // wrapper pid, so without an override the parent would receive a report
+  // apparently sent by itself.
+  let dir: string;
+  let out: string;
+  let argv1: string | undefined;
+
+  beforeEach(() => {
+    dir = mkdtempSync(path.join(tmpdir(), "ay-ping-"));
+    out = path.join(dir, "captured.json");
+    const stub = path.join(dir, "stub.mjs");
+    writeFileSync(
+      stub,
+      `import { writeFileSync } from "node:fs";
+       let body = "";
+       process.stdin.setEncoding("utf8");
+       process.stdin.on("data", (c) => (body += c));
+       process.stdin.on("end", () => {
+         writeFileSync(${JSON.stringify(out)}, JSON.stringify({
+           args: process.argv.slice(2),
+           body,
+           ayPid: process.env.AGENT_YES_PID,
+         }));
+         process.exit(0);
+       });`,
+    );
+    argv1 = process.argv[1];
+    process.argv[1] = stub;
+  });
+
+  afterEach(() => {
+    if (argv1 !== undefined) process.argv[1] = argv1;
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("hands the report to `ay send <target> - --force --no-wait` on stdin", async () => {
+    const body = buildPingBody(d({ reason: "stuck", question: "Approve?" }), self, "tail line");
+    await expect(
+      deliverPing({
+        target: "agt_parent",
+        body,
+        selfWrapperPid: 4242,
+        timeoutMs: 20_000,
+      }),
+    ).resolves.toBe(true);
+
+    const captured = JSON.parse(readFileSync(out, "utf8"));
+    expect(captured.args).toEqual(["send", "agt_parent", "-", "--force", "--no-wait"]);
+    expect(captured.body).toBe(body);
+    // Attributed to the CHILD's wrapper, not the inherited parent's.
+    expect(captured.ayPid).toBe("4242");
+  });
+});

package/ts/parentPingSend.ts

@@ -0,0 +1,148 @@
+/**
+ * Delivery side of the sub-agent→parent ping: turn a `PingDecision` into a
+ * message and inject it into the parent's stdin.
+ *
+ * We deliberately deliver through the real `ay send` subprocess rather than
+ * writing the parent's FIFO directly. `ay send` is where the `<ay-msg nonce
+ * from …>` attribution wrapper, the paste/submit handling and the durable
+ * message log all live; re-implementing any of that here would drift. The cost
+ * is one short-lived process per ping, which happens at most a handful of times
+ * per agent lifetime.
+ *
+ * Two flags are load-bearing:
+ *   --force    the recency guard ("you must have tailed this target lately")
+ *              exists to stop an agent from firing at a target it never looked
+ *              at. A child reporting to its own parent is the one relationship
+ *              where that guard is pure false-positive.
+ *   --no-wait  the wrapper must never block its own PTY loop waiting for the
+ *              parent's screen to settle.
+ */
+
+import { spawn } from "node:child_process";
+import type { PingDecision } from "./parentPing.ts";
+import { shortenHome } from "./initMsg.ts";
+import { logger } from "./logger.ts";
+
+export interface PingSelf {
+  cli: string;
+  /** The child AGENT's pid — what the parent will use in `ay tail <pid>`. */
+  pid: number;
+  cwd: string;
+  /** The task this child was spawned with, for a one-line reminder. */
+  prompt?: string | null;
+  /** Exit code, when the ping reason is "exited". */
+  exitCode?: number | null;
+}
+
+const HEADLINE: Record<PingDecision["reason"], string> = {
+  finished: "looks FINISHED (idle at its prompt, no longer working)",
+  stuck: "is STUCK (parked waiting for input / not making progress)",
+  exited: "has EXITED",
+};
+
+/** Trim to `max` chars on a whitespace boundary where possible. */
+function clip(s: string, max: number): string {
+  const t = s.trim();
+  if (t.length <= max) return t;
+  return t.slice(0, max).replace(/\s+\S*$/, "") + "…";
+}
+
+/**
+ * The report body. Pure so the wording is testable and stable.
+ *
+ * It is explicitly framed as coming from the WRAPPER, not the agent: the agent
+ * itself may have said nothing at all (that is usually why this fires), and a
+ * parent that mistakes an automatic ping for the child's considered answer would
+ * act on a summary the child never wrote. The tail is included because the whole
+ * point is that the parent is not tailing.
+ */
+export function buildPingBody(
+  decision: PingDecision,
+  self: PingSelf,
+  tail?: string | null,
+): string {
+  const attempt = decision.attempt > 1 ? ` (reminder #${decision.attempt - 1} — no reply yet)` : "";
+  const lines = [
+    `<ay-report from ${self.cli} #${self.pid} @ ${shortenHome(self.cwd)}>`,
+    `Your sub-agent ${HEADLINE[decision.reason]}${attempt}.`,
+    `This is an automatic report from its agent-yes wrapper, not from the agent itself —`,
+    `treat the tail below as evidence, not as its answer.`,
+  ];
+  if (self.prompt) lines.push(`Task it was spawned with: ${clip(self.prompt, 200)}`);
+  if (decision.reason === "exited" && self.exitCode != null)
+    lines.push(`Exit code: ${self.exitCode}`);
+  if (decision.question) lines.push(`It is asking: ${clip(decision.question, 300)}`);
+  if (tail?.trim()) {
+    lines.push(`Last output:`, clip(tail, 1200));
+  }
+  lines.push(
+    decision.reason === "exited"
+      ? `Next: ay result get ${self.pid} | ay cat ${self.pid}`
+      : `Next: ay tail ${self.pid} | ay send ${self.pid} "..." | ay exit ${self.pid}`,
+    `</ay-report>`,
+  );
+  return lines.join("\n");
+}
+
+/**
+ * Argv for the `ay send` that carries `body` to `target`. Re-invokes THIS
+ * entrypoint (argv[0] + argv[1]) rather than a bare `ay` on PATH, so a wrapper
+ * running from a checkout, a global link, or `npx` all ping through the exact
+ * same build they are part of.
+ */
+export function buildSendArgv(target: string, argv1?: string): { cmd: string; args: string[] } {
+  const send = ["send", target, "-", "--force", "--no-wait"];
+  if (argv1) return { cmd: process.execPath, args: [argv1, ...send] };
+  return { cmd: "ay", args: send };
+}
+
+/**
+ * Fire one ping. Resolves when the send subprocess exits; never throws — a
+ * failed report must not take down the agent it is reporting about.
+ *
+ * `selfWrapperPid` is stamped as AGENT_YES_PID for the subprocess so `ay send`
+ * attributes the message to THIS child. Without it the subprocess would inherit
+ * the wrapper's own AGENT_YES_PID — which is the PARENT's wrapper pid — and the
+ * parent would receive a message apparently sent by itself.
+ */
+export async function deliverPing(opts: {
+  target: string;
+  body: string;
+  selfWrapperPid: number;
+  timeoutMs?: number;
+}): Promise<boolean> {
+  const { cmd, args } = buildSendArgv(opts.target, process.argv[1]);
+  return await new Promise<boolean>((resolve) => {
+    let done = false;
+    const finish = (ok: boolean) => {
+      if (done) return;
+      done = true;
+      resolve(ok);
+    };
+    try {
+      const child = spawn(cmd, args, {
+        stdio: ["pipe", "ignore", "ignore"],
+        env: { ...process.env, AGENT_YES_PID: String(opts.selfWrapperPid) },
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(false);
+      }, opts.timeoutMs ?? 30_000);
+      timer.unref?.();
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        logger.debug(`[parent-ping] send failed: ${err.message}`);
+        finish(false);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        finish(code === 0);
+      });
+      child.stdin?.on("error", () => {});
+      child.stdin?.end(opts.body);
+    } catch (err) {
+      logger.debug(`[parent-ping] spawn failed: ${(err as Error).message}`);
+      finish(false);
+    }
+  });
+}

package/ts/parentWatching.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { isParentWatching, parseReportMode, shouldDeliverReport } from "./parentWatching.ts";
+
+describe("parseReportMode", () => {
+  it("defaults to auto for unset or unrecognised values", () => {
+    expect(parseReportMode(undefined)).toBe("auto");
+    expect(parseReportMode("")).toBe("auto");
+    expect(parseReportMode("yes")).toBe("auto");
+    expect(parseReportMode("auto")).toBe("auto");
+  });
+
+  it("accepts always/never, case- and space-insensitively", () => {
+    expect(parseReportMode("always")).toBe("always");
+    expect(parseReportMode(" ALWAYS ")).toBe("always");
+    expect(parseReportMode("Never")).toBe("never");
+  });
+});
+
+describe("shouldDeliverReport", () => {
+  const at = (over: Partial<Parameters<typeof shouldDeliverReport>[0]> = {}) =>
+    shouldDeliverReport({
+      mode: "auto",
+      parentIsWatching: false,
+      reason: "finished",
+      ...over,
+    });
+
+  it("auto sends when nobody is watching — the case this feature exists for", () => {
+    expect(at({ reason: "finished" })).toBe(true);
+    expect(at({ reason: "stuck" })).toBe(true);
+  });
+
+  it("auto stays quiet when the parent is already monitoring", () => {
+    expect(at({ parentIsWatching: true, reason: "finished" })).toBe(false);
+    expect(at({ parentIsWatching: true, reason: "stuck" })).toBe(false);
+  });
+
+  it("auto still sends `exited` to a watching parent — a poll can miss it entirely", () => {
+    expect(at({ parentIsWatching: true, reason: "exited" })).toBe(true);
+  });
+
+  it("never suppresses everything, including exited", () => {
+    for (const reason of ["finished", "stuck", "exited"] as const) {
+      expect(at({ mode: "never", reason })).toBe(false);
+      expect(at({ mode: "never", reason, parentIsWatching: true })).toBe(false);
+    }
+  });
+
+  it("always sends even to a watching parent", () => {
+    for (const reason of ["finished", "stuck", "exited"] as const) {
+      expect(at({ mode: "always", reason, parentIsWatching: true })).toBe(true);
+    }
+  });
+});
+
+describe("isParentWatching", () => {
+  it("fails open (false) when there is no watcher and no recent read", async () => {
+    // Nothing in this test process has watched or tailed these synthetic pids.
+    await expect(isParentWatching(2 ** 30, 2 ** 30 + 1, 2 ** 30 + 2)).resolves.toBe(false);
+  });
+});

package/ts/parentWatching.ts

@@ -0,0 +1,89 @@
+/**
+ * "Is my parent already monitoring me?" — the suppression signal for the
+ * automatic finished/stuck/exited push.
+ *
+ * A parent harness that HAS a monitor loop (Claude Code's Monitor tool, an
+ * `ay ls --watch` NDJSON stream, `ay notify watch`, or just a polling `ay tail`)
+ * already sees the child go idle / needs_input / stopped, with better fidelity
+ * and on its own schedule. Injecting an `<ay-report …>` into that parent's stdin
+ * on top of it is pure noise — worse than noise, since a message lands in the
+ * parent's composer and interrupts whatever it was doing.
+ *
+ * So the push is a FALLBACK, not a duplicate channel: it fires only when nobody
+ * is looking. Two independent signals count as "looking", and either is enough:
+ *
+ *   1. A live `ay notify watch` heartbeat for this parent (the explicit,
+ *      purpose-built watcher — see notifyStore's watcher registry).
+ *   2. This parent tailed/read THIS child within the read window — the same
+ *      recency ledger `ay send`'s misdelivery guard uses. This is what catches
+ *      an ad-hoc monitor loop that just polls `ay tail`/`ay ls`, which is what a
+ *      harness-driven parent actually does.
+ *
+ * Failing OPEN (assume not watching, so we do send) is deliberate: a duplicate
+ * report is a minor annoyance, a silently stranded parent is the bug this whole
+ * feature exists to fix.
+ */
+
+import { logger } from "./logger.ts";
+
+/** How the wrapper's automatic report behaves. `AGENT_YES_REPORT_PARENT`. */
+export type ReportMode = "auto" | "always" | "never";
+
+/**
+ * Parse the mode from the env value. Anything unrecognised (including unset)
+ * is `auto` — the setting is an escape hatch, not something to fail a run over.
+ */
+export function parseReportMode(raw: string | undefined): ReportMode {
+  const v = raw?.trim().toLowerCase();
+  return v === "always" || v === "never" ? v : "auto";
+}
+
+/**
+ * Decide whether to actually deliver a report. Pure, so the policy is testable
+ * without touching the fs.
+ *
+ * `always` and `never` are absolute. `auto` sends only when the parent shows no
+ * sign of monitoring — EXCEPT that `exited` always goes out: it is terminal, it
+ * is the one edge a poll can miss entirely (the child's record can be reaped
+ * between two polls), and it can never repeat, so it cannot become spam.
+ */
+export function shouldDeliverReport(opts: {
+  mode: ReportMode;
+  parentIsWatching: boolean;
+  reason: "finished" | "stuck" | "exited";
+}): boolean {
+  if (opts.mode === "never") return false;
+  if (opts.mode === "always") return true;
+  if (opts.reason === "exited") return true;
+  return !opts.parentIsWatching;
+}
+
+/**
+ * Whether `parentWrapperPid` currently appears to be monitoring the agent
+ * `selfAgentPid`. Best-effort and fail-open (returns false on any error).
+ */
+export async function isParentWatching(
+  parentWrapperPid: number,
+  parentAgentPid: number,
+  selfAgentPid: number,
+  now = Date.now(),
+): Promise<boolean> {
+  try {
+    const { liveWatchers } = await import("./notifyStore.ts");
+    const watchers = await liveWatchers(now);
+    if (watchers.has(parentWrapperPid)) return true;
+  } catch (error) {
+    logger.debug("[parent-ping] watcher lookup failed:", error);
+  }
+  try {
+    // Imported lazily and only when a report is about to fire (a handful of
+    // times per agent lifetime), so subcommands.ts never lands on the wrapper's
+    // startup path.
+    const { lastReadAt, READ_WINDOW_MS } = await import("./subcommands.ts");
+    const last = await lastReadAt(`agent:${parentAgentPid}`, selfAgentPid);
+    if (last !== null && now - last <= READ_WINDOW_MS) return true;
+  } catch (error) {
+    logger.debug("[parent-ping] read-recency lookup failed:", error);
+  }
+  return false;
+}

package/ts/subcommands.ts

@@ -126,7 +126,7 @@ async function compactNotes(): Promise<void> {
 // wrong agent (e.g. you tail "babaiban" but a send resolves to "qq-cli").
 // ---------------------------------------------------------------------------
 
-const READ_WINDOW_MS = 60_000; // "read recently" = within the last minute
+export const READ_WINDOW_MS = 60_000; // "read recently" = within the last minute
 
 // Max time writeToIpc will keep retrying a backed-up FIFO before erroring. A live
 // agent drains its stdin in milliseconds; only a wedged reader hits this.
@@ -185,7 +185,7 @@ async function recordRead(by: string, target: number): Promise<void> {
   }
 }
 
-async function lastReadAt(by: string, target: number): Promise<number | null> {
+export async function lastReadAt(by: string, target: number): Promise<number | null> {
   const map = await readReads();
   return map.get(`${by}${READS_KEY_SEP}${target}`) ?? null;
 }
@@ -775,11 +775,20 @@ async function buildAgentContextSection(self: GlobalPidRecord): Promise<string>
     : parent
       ? `Spawned by agent pid ${parent.pid} (${parent.cli}) in ${shortenPath(parent.cwd)}.`
       : `Nested under a parent (wrapper pid ${self.parent_pid}) whose record isn't in the local registry.`;
+  // The reporting duty is stated in the `<ay-init-msg>` block wrapping this
+  // agent's initial prompt, but that block scrolls out of a long session (or is
+  // compacted away) long before the agent finishes. `ay help` is where an agent
+  // goes when it has lost the thread, so restate the obligation here.
+  const dutyLine = parent
+    ? `  You owe it a report: \`ay send ${parent.agent_id || parent.pid} "..."\` when you finish, and\n` +
+      `  when you are blocked. It is not watching your terminal.\n`
+    : ``;
 
   return (
     `You are running inside an agent:\n` +
     `  ${whoAmI}\n` +
     `  ${parentLine}\n` +
+    dutyLine +
     `\n` +
     `As an agent, you can:\n` +
     `  Spawn a sub-agent:\n` +

package/ts/trayApp.spec.ts

@@ -28,7 +28,33 @@ function setPlatform(value: string) {
 
 // Stub the Bun global's spawn so launchTray/stopTray never spawn real processes.
 const spawnMock = vi.fn();
-let originalBun: unknown;
+let originalSpawn: unknown;
+let hadBun: boolean;
+
+type BunLike = { spawn?: unknown };
+
+// Under the BUN runtime `globalThis.Bun` is both non-writable AND
+// NON-CONFIGURABLE, so it can be neither assigned (`globalThis.Bun = …` throws
+// "Attempted to assign to readonly property" in an ESM module, which is always
+// strict) nor redefined via Object.defineProperty. Its `spawn` property IS
+// writable, though — so we stub the method in place instead of swapping the
+// whole global. Under node there is no Bun global at all, so we define a minimal
+// stand-in and remove it again on restore.
+function installBunSpawn(fn: unknown): void {
+  const g = globalThis as { Bun?: BunLike };
+  if (!g.Bun) {
+    Object.defineProperty(globalThis, "Bun", { value: {}, configurable: true, writable: true });
+  }
+  (globalThis as { Bun: BunLike }).Bun.spawn = fn;
+}
+
+function restoreBunSpawn(spawn: unknown, present: boolean): void {
+  if (!present) {
+    delete (globalThis as { Bun?: BunLike }).Bun;
+    return;
+  }
+  (globalThis as { Bun: BunLike }).Bun.spawn = spawn;
+}
 function goodChild() {
   return { unref: vi.fn(), exited: Promise.resolve(0) };
 }
@@ -49,14 +75,15 @@ describe("trayApp", () => {
     mockRustBinary.findTrayLauncher.mockReturnValue(undefined);
     mockHome.agentYesHome.mockReturnValue("/tmp/ay-home");
     spawnMock.mockReturnValue(goodChild());
-    originalBun = (globalThis as { Bun?: unknown }).Bun;
-    (globalThis as { Bun?: unknown }).Bun = { spawn: spawnMock };
+    hadBun = "Bun" in globalThis;
+    originalSpawn = (globalThis as { Bun?: BunLike }).Bun?.spawn;
+    installBunSpawn(spawnMock);
     stdout = vi.spyOn(process.stdout, "write").mockReturnValue(true);
     stderr = vi.spyOn(process.stderr, "write").mockReturnValue(true);
   });
 
   afterEach(() => {
-    (globalThis as { Bun?: unknown }).Bun = originalBun;
+    restoreBunSpawn(originalSpawn, hadBun);
     setPlatform(originalPlatform);
     stdout.mockRestore();
     stderr.mockRestore();

package/ts/ws.ts

@@ -139,22 +139,27 @@ function isCheckoutRoot(dir: string): boolean {
 }
 
 // List real subdirectories (no symlinks, no dotdirs), tolerating vanished dirs.
+//
+// The ITERATION is inside the try, not just the open. `opendir` is lazy on some
+// runtimes (notably Bun): the ENOENT for a missing directory surfaces from the
+// first `for await` step, not from the `await opendir(...)`, so a try that wraps
+// only the open lets it escape — walkWorkspaces would throw on a missing root
+// instead of returning [].
 async function subdirs(dir: string): Promise<string[]> {
   const out: string[] = [];
-  let d: Awaited<ReturnType<typeof opendir>>;
   try {
-    d = await opendir(dir);
-  } catch {
-    return out;
-  }
-  for await (const ent of d) {
-    if (ent.name.startsWith(".")) continue;
-    if (ent.isDirectory()) {
-      out.push(ent.name);
-    } else if (ent.isSymbolicLink()) {
-      // never follow symlinks — a link cycle under tree/ must not loop the walk
-      continue;
+    for await (const ent of await opendir(dir)) {
+      if (ent.name.startsWith(".")) continue;
+      if (ent.isDirectory()) {
+        out.push(ent.name);
+      } else if (ent.isSymbolicLink()) {
+        // never follow symlinks — a link cycle under tree/ must not loop the walk
+        continue;
+      }
     }
+  } catch {
+    // Vanished/unreadable dir — a partial listing is still the right answer.
+    return out.sort();
   }
   return out.sort();
 }

package/dist/subcommands-Cgt2-kjg.js

@@ -1,10 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-Dq4KY2IV.js";
-import "./messageLog-BYFwioFY.js";
-import "./e2e-CUMZC53I.js";
-import "./configShared-DtHMBCl7.js";
-import { A as readLogForRender, B as resolveResumeArgs, C as isUnknownManagerToken, D as matchKeyword, E as listRecords, F as renderLogTailLines, G as stopTipForCli, H as runSubcommand, I as renderRawLog, J as writeKeysPaced, K as submitAndConfirm, L as renderRawLogLines, M as readPtysize, N as recentMessageEdges, O as menuSelectKeys, P as recentReadEdges, R as resolveOne, S as isSubcommand, T as lastStdinAt, U as snapshotStatus, V as restartHintLines, W as stdinActivityPath, Y as writeToIpc, _ as isAgentStuck, a as backoffWhileTyping, b as isPidAlive, c as controlCodeFromName, d as deriveLiveStatus, f as extractBadges, g as finalizedLines, h as extractTaskCounts, i as TYPING_WINDOW_MS, j as readNotes, k as readAgentPtysize, l as cursorAbs, m as extractNeedsInput, n as MAX_RENDER_BYTES, o as cmdDeepseek, p as extractMenu, q as waitForLogQuiet, r as READ_PAGE_DEFAULT, s as cmdHelp, t as GRACEFUL_EXIT_COMMANDS, u as deriveLiveState, v as isBareManagerInvocation, w as isUserTyping, x as isSlashCommand, y as isExitRequest, z as resolveReadWindow } from "./subcommands-CQPnT5qu.js";
-import "./webrtcLink-CS4D-3G1.js";
-import "./remotes-iIvqiFWK.js";
-
-export { cmdHelp, isBareManagerInvocation, isSubcommand, isUnknownManagerToken, runSubcommand };

package/dist/trayApp-CmwwBg8v.js

@@ -1,5 +0,0 @@
-import "./versionChecker-CMOLbEEi.js";
-import "./rustBinary-DSVRhDzO.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-UglHbk_m.js";
-
-export { cmdTray };