baychat 0.13.1 → 0.15.0

package/dist/relay/commands.js

@@ -35,10 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdRelayStart = cmdRelayStart;
 exports.ensureRelayInstalled = ensureRelayInstalled;
+exports.tryRelayStatus = tryRelayStatus;
 exports.cmdRelayStatus = cmdRelayStatus;
 exports.cmdRelayStop = cmdRelayStop;
+exports.shouldFallBackToMailbox = shouldFallBackToMailbox;
+exports.attachViaMailbox = attachViaMailbox;
+exports.renderSessionLine = renderSessionLine;
 exports.cmdRelayAttach = cmdRelayAttach;
 exports.resolveRuntimeBin = resolveRuntimeBin;
+exports.decideRuntimeBin = decideRuntimeBin;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
@@ -46,15 +51,24 @@ const path = __importStar(require("path"));
 const util_1 = require("util");
 const adapters_1 = require("./adapters");
 const autostart_1 = require("./autostart");
+const runtime_binary_1 = require("../runtime-binary");
+const owner_pid_1 = require("./owner-pid");
+const parent_watch_1 = require("./parent-watch");
 const daemon_1 = require("./daemon");
 const resume_1 = require("./resume");
+const mailbox_1 = require("./mailbox");
 const socket_1 = require("./socket");
+const parent_watch_2 = require("./parent-watch");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
 /** Connect to a running daemon, or explain that there isn't one. */
 async function connectOrFail() {
     const sockPath = (0, socket_1.socketPath)();
-    if (!(await (0, socket_1.probeSocket)(sockPath))) {
-        throw new Error("no relay is running — start one with `baychat relay start`");
+    const probe = await (0, socket_1.probeSocketDetailed)(sockPath);
+    if (!probe.alive) {
+        // NOT a flat "no relay is running". See `describeProbeFailure`: a refused
+        // pipe and a wedged daemon are both live relays, and telling someone to
+        // start another one is the one instruction that makes those worse.
+        throw new Error((0, socket_1.describeProbeFailure)(sockPath, probe));
     }
     return net.createConnection(sockPath);
 }
@@ -165,6 +179,26 @@ async function ensureRelayInstalled() {
         return `Relay: could not start automatically (${err instanceof Error ? err.message : String(err)}). Run \`baychat relay start\` yourself.`;
     }
 }
+/**
+ * The daemon's status, or null when there is no daemon.
+ *
+ * `cmdRelayStatus` treats an absent relay as an error to report, which is right
+ * for a command whose whole subject is the relay. `doctor` needs the opposite:
+ * "not running" is one finding among several and must not abort the rest of the
+ * report, so the absence is a value here rather than a thrown error.
+ */
+async function tryRelayStatus() {
+    try {
+        return await request(await connectOrFail(), { type: "status" });
+    }
+    catch {
+        // Every failure means the same thing to a caller that only wants to know
+        // whether the relay can answer: no socket, a stale socket, or a daemon too
+        // wedged to reply are all "no usable relay". `doctor` reports that state
+        // itself; there is nothing here worth logging over it.
+        return null;
+    }
+}
 async function cmdRelayStatus() {
     let status;
     try {
@@ -179,24 +213,98 @@ async function cmdRelayStatus() {
     console.log(`  polls: ${status.polls}   delivered: ${status.delivered}   cursor: ${status.cursor ?? "—"}`);
     if (status.lastError)
         console.log(`  last error: ${status.lastError}`);
+    // Computed before the session list so a line can report its own last failure.
+    const byName = new Map(status.sessions.map((s) => [s.name, s]));
+    /**
+     * Why this failure no longer stands, or undefined if it still does.
+     *
+     * Returns the REASON rather than a boolean so the line can say what cleared
+     * it. "(stale)" with no cause is the same species of unexamined claim this
+     * command exists to stop printing.
+     */
+    const staleReason = (p) => {
+        const session = byName.get(p.session);
+        // No session at all means nothing has been repaired — that is live, not stale.
+        if (!session)
+            return undefined;
+        // TWO WITNESSES, AND ONLY TWO. Everything weaker was tried and was wrong.
+        //
+        // A live SOCKET is demonstrably reachable — the attach is holding it now, so
+        // whatever this entry records is no longer true. `attached` alone is not
+        // that: the daemon sets it for a mailbox REGISTRATION too, and the fifo rung
+        // itself refuses to trust one, proving a reader with ENXIO on every write.
+        if (session.attached && session.transport !== "fifo")
+            return "an attach is holding the socket now";
+        // A delivery that actually LANDED after the failure. `registeredAt` was used
+        // for this and should not have been: it proves `relay attach` was rerun, and
+        // the npm/snap outage was made entirely of attaches that registered
+        // perfectly and then failed every single delivery.
+        const delivered = session.lastDeliveredAt;
+        if (delivered !== undefined && Date.parse(delivered) > Date.parse(p.at)) {
+            return `a later delivery landed at ${delivered}`;
+        }
+        return undefined;
+    };
+    const lastFailureFor = new Map();
+    for (const p of status.pending) {
+        if (!staleReason(p))
+            lastFailureFor.set(p.session, p.reason);
+    }
     console.log(`\nSessions (${status.sessions.length}):`);
     if (status.sessions.length === 0) {
         console.log("  none — a session registers itself by running `baychat relay attach`");
     }
     for (const s of status.sessions) {
-        const state = s.attached ? "attached" : s.resumeId ? "detached (headless resume ready)" : "detached (no resume id)";
+        const state = sessionState(s, lastFailureFor.get(s.name));
         console.log(`  ${s.name}  [${s.runtime}]  ${state}`);
         console.log(`     ${resumeLabel(s)}`);
     }
+    // HELD is a THIRD state and prints as itself.
+    //
+    // These messages reached this box, were not delivered, and are not a failure:
+    // the agent is mid-turn and they go over the moment it re-arms. Folding them
+    // into pending would paint a working relay red; leaving them out is what we
+    // came from — before this they lived only in the daemon's heap, so a restart
+    // lost them silently and `relay status` never mentioned they had existed.
+    //
+    // Deliberately does NOT affect the exit code. A monitor should page on
+    // pending, never on an agent that is simply busy.
+    const held = status.held ?? [];
+    if (held.length > 0) {
+        const total = held.reduce((n, h) => n + h.count, 0);
+        console.log(`\nHELD (${total}) — waiting for a busy session to re-arm, not lost:`);
+        for (const h of held) {
+            console.log(`  ${h.heldAt}  ${h.session}  ${h.count} message(s) in ${h.conversationId}`);
+        }
+    }
     // Pending is the point of the whole command: these are messages that reached
     // this machine and that nobody answered.
+    //
+    // But a failure the operator has already FIXED must stop shouting. Pending
+    // records are never removed, so before this a single bad afternoon left the
+    // command exiting 2 forever — and a status that is permanently red is a status
+    // nobody reads. An entry that predates its session's current registration
+    // describes a session that has since been repaired: still worth printing as
+    // history, no longer worth alerting on.
     if (status.pending.length > 0) {
-        console.log(`\nDELIVERY PENDING (${status.pending.length}) — reached this box, not answered:`);
+        const live = status.pending.filter((p) => !staleReason(p));
+        const stale = status.pending.length - live.length;
+        const heading = live.length > 0
+            ? `DELIVERY PENDING (${live.length}) — reached this box, not answered:`
+            : `DELIVERY PENDING (0 live, ${stale} historical) — every one has been superseded by a later success:`;
+        console.log(`\n${heading}`);
         for (const p of status.pending.slice(-10)) {
-            console.log(`  ${p.at}  ${p.session}  msg ${p.messageId}`);
+            const why = staleReason(p);
+            console.log(`  ${p.at}  ${p.session}  msg ${p.messageId}${why ? `  (stale — ${why})` : ""}`);
             console.log(`     ${p.reason}`);
         }
-        return 2; // distinct exit code so a monitor can alert on it
+        if (live.length > 0 && stale > 0) {
+            console.log(`  (${stale} older entr${stale === 1 ? "y" : "ies"} marked stale — superseded by a later success.)`);
+        }
+        // Distinct exit code so a monitor can alert on it — but only for failures
+        // that still stand.
+        if (live.length > 0)
+            return 2;
     }
     return 0;
 }
@@ -265,21 +373,250 @@ async function cmdRelayStop() {
  * which then reads the room properly through the BayChat tools. Exit 2 means
  * the wait lapsed with nothing to report.
  */
+/**
+ * Is this probe failure the sandboxed case, and ONLY that?
+ *
+ * `denied` means a daemon exists and refused us — precisely a sandbox or token
+ * boundary, and precisely what the mailbox is for. Every other reason keeps
+ * today's error, deliberately:
+ *
+ *   - `absent` — there is no relay. A mailbox would be created that no daemon
+ *     is watching, and the agent would block on a FIFO forever believing it was
+ *     reachable. That is the exact failure this transport exists to end, and
+ *     the fallback must not reintroduce it.
+ *   - `timeout` / `error` — a wedged or unexplained daemon. Papering over it
+ *     with a second channel hides the thing someone needs to fix.
+ */
+function shouldFallBackToMailbox(probe) {
+    return !probe.alive && probe.reason === "denied";
+}
+/**
+ * Arm over the mailbox: register by file, then block on a FIFO read.
+ *
+ * FOREGROUND, and it must stay foreground. A backgrounded process does not
+ * survive the sandbox: measured 2026-08-30, `nohup bash -c 'sleep 25; …' &`
+ * inside Codex never wrote its file, because bubblewrap tears down the mount
+ * namespace and kills the process group when the command returns. Telling a
+ * sandboxed agent to background this would be handing it an instruction that
+ * cannot work — which is how one came to report "Armed and joined the group"
+ * having armed nothing at all.
+ */
+async function attachViaMailbox(opts) {
+    // PROVE the root by creating it, rather than resolving one and hoping. A
+    // sandbox that permits /tmp may still refuse XDG_RUNTIME_DIR, and only this
+    // process can find that out.
+    const dir = (0, mailbox_1.pickUsableMailboxDir)(opts.session);
+    // Declare the path; the daemon creates the FIFO. Making one requires spawning
+    // `mkfifo(1)`, and a sandbox that permits writing files still refuses to spawn
+    // a helper binary (measured 2026-08-30: `spawnSync mkfifo EPERM`).
+    const fifo = (0, mailbox_1.wakeFifoPath)(dir);
+    (0, mailbox_1.writeRegistration)(dir, {
+        session: opts.session,
+        runtime: opts.runtime,
+        resumeId: opts.resume.ok ? opts.resume.resumeId : undefined,
+        resumeSource: opts.resume.ok ? opts.resume.source : undefined,
+        resumeEvidence: opts.resume.ok ? opts.resume.evidence : undefined,
+        resumeCwd: opts.resume.ok ? opts.resume.cwd : undefined,
+        cwd: process.cwd(),
+        // Resolved inside the session, for the same reason the socket rung does it:
+        // the binary a session was launched with is knowable here and nowhere else.
+        // Passed in rather than re-probed — see `decideRuntimeBin`.
+        runtimeBin: opts.runtimeBin,
+        fifo,
+        pid: process.pid,
+        // The SESSION's pid, not this attach's and not its shell's. `pid` above dies
+        // with every wake, and `process.ppid` is a throwaway wrapper that exits in
+        // seconds — recording either told the daemon a live session had gone, and it
+        // spawned a headless duplicate. See `currentOwnerPid`.
+        ownerPid: opts.ownerPid ?? (0, owner_pid_1.currentOwnerPid)(opts.runtime),
+        registeredAt: new Date().toISOString(),
+    });
+    const timeoutMs = opts.timeoutMs;
+    // NON-BLOCKING, because the obvious version cannot be cancelled.
+    //
+    // `readFile(fifo)` blocks in `open(2)` inside the libuv threadpool. No signal
+    // reaches it, and — measured — `process.exit()` does not end the process
+    // either: Node waits for that worker, so a "timeout" printed there is a lie the
+    // caller then hangs behind. An earlier fix here claimed a bound and shipped
+    // exactly that; the test missed it by never reaching the read.
+    //
+    // `O_RDONLY | O_NONBLOCK` opens a FIFO with no writer IMMEDIATELY, and reads
+    // then return nothing until the daemon writes. Polling that is genuinely
+    // cancellable: the deadline is a plain loop condition, the process can exit on
+    // its own, and there is nothing left blocked behind it.
+    const deadline = timeoutMs === undefined ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+    try {
+        await (0, mailbox_1.awaitWakeFifo)(fifo, Math.min(timeoutMs ?? 30_000, 30_000));
+    }
+    catch (err) {
+        // The relay never made the FIFO. Bounded arm-once treats that as its timeout
+        // rather than an error: the registration above still happened, which is the
+        // point of arming once.
+        if (timeoutMs === undefined)
+            throw err;
+        console.log(err instanceof Error ? err.message : String(err));
+        return 2;
+    }
+    console.log(`Attached as "${opts.session}" over a mailbox FIFO (${fifo}). Waiting for messages…`);
+    const raw = await readWakeBounded(fifo, deadline);
+    if (raw === "timeout") {
+        console.log("No new messages before timeout. Registered and reachable — the relay will wake this session.");
+        return 2;
+    }
+    const frame = JSON.parse(raw.trim());
+    console.log(`WAKE ${frame.messages.length} message(s) in ${frame.conversationId}:`);
+    for (const m of frame.messages) {
+        const flag = m.shouldRespond ? " [shouldRespond=true]" : "";
+        console.log(`  (${m.id}) ${m.senderType} ${m.senderId}${flag}: ${m.content}`);
+    }
+    return 0;
+}
+/**
+ * Wait for one wake frame on a FIFO, without ever blocking uninterruptibly.
+ *
+ * Returns "timeout" instead of throwing: for `arm-once` a timeout is the normal
+ * ending, not a failure — registration already happened, and the relay owns
+ * every later wake.
+ */
+async function readWakeBounded(fifo, deadline, pollMs = 25) {
+    const handle = await fs.promises.open(fifo, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+    try {
+        const buf = Buffer.alloc(64 * 1024);
+        let acc = "";
+        for (;;) {
+            let bytes = 0;
+            try {
+                ({ bytesRead: bytes } = await handle.read(buf, 0, buf.length, null));
+            }
+            catch (err) {
+                // EAGAIN is "no writer has written yet" on a non-blocking FIFO, which is
+                // the normal state of this wait. Anything else is a real fault.
+                if (err.code !== "EAGAIN")
+                    throw err;
+            }
+            // A read of 0 is NOT end-of-input here. With no writer attached a
+            // non-blocking FIFO reports EOF, and the writer we are waiting for has not
+            // arrived yet — treating it as the end would turn every wait into an
+            // instant empty answer.
+            if (bytes > 0) {
+                acc += buf.subarray(0, bytes).toString("utf8");
+                if (acc.includes("\n"))
+                    return acc;
+            }
+            if (Date.now() >= deadline)
+                return "timeout";
+            await new Promise((r) => setTimeout(r, pollMs));
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** The state half of one `relay status` session line. */
+function sessionState(s, lastWakeFailure) {
+    // "registered", not "attached", for the FIFO rung — and the difference is not
+    // pedantry. A socket attach IS a held connection, so `attached` is an
+    // observation. A mailbox registration is a file on disk; whether the agent is
+    // still blocked on its FIFO cannot be checked without ending the wait, since
+    // a reader blocked in open() holds no descriptor for /proc to see and opening
+    // the write end to look would signal EOF. Delivery is the only honest probe,
+    // and it makes it: a wake with no reader is recorded pending, never delivered.
+    // A live SOCKET outranks a past failure: the attach is holding it right now.
+    // A FIFO REGISTRATION does not, and must not short-circuit the check below —
+    // that is the same "a registration is not a reader" rule `staleReason` applies
+    // to the pending list, and leaving it out here meant a session whose last wake
+    // died still printed a clean `registered (fifo)` on the one line a human reads.
+    if (s.attached && s.transport !== "fifo")
+        return "attached";
+    if (s.attached && !lastWakeFailure)
+        return "registered (fifo)";
+    if (s.attached)
+        return `registered (fifo) — LAST WAKE FAILED, not reachable: ${lastWakeFailure}`;
+    // "headless resume ready" is a claim about a PRECONDITION — that we hold an id
+    // — and for a long time it was printed even while every wake using that id had
+    // failed. A non-engineer reads "ready" as "fine", so the one line that answers
+    // "is anything listening?" was the line most likely to mislead. If a wake has
+    // actually been tried and failed since this session registered, say THAT: an
+    // outcome outranks a precondition.
+    if (lastWakeFailure)
+        return `detached — LAST WAKE FAILED, not reachable: ${lastWakeFailure}`;
+    // INTERRUPTED, NOT GONE — and this line used to read "headless resume ready",
+    // which sounds fine and is now actively false.
+    //
+    // Stopping a task in the driving harness kills its background `relay attach`
+    // from OUTSIDE the process: no self-detach line is printed, nothing fails, the
+    // registration simply stops having a listener. And interrupting your own agent
+    // is an ORDINARY thing to do — every other fault in this release needed an
+    // unusual machine; this one needs Ctrl+C.
+    //
+    // "Headless resume ready" is wrong here for a specific reason: the daemon will
+    // NOT resume a session whose owning process is still alive — that is the
+    // no-clone guard — so a wake is held as pending instead. Reachable is exactly
+    // what this session is not.
+    //
+    // SCOPED TO RUNTIMES WITH NO LIVE-SESSION QUEUE. Codex is deliberately
+    // `arm-once`: its bounded attach exits and the session is SUPPOSED to sit
+    // detached with a live owner, because rung 2 hands the message to
+    // `codex queue` — which reaches the live session, and is tried BEFORE the
+    // no-clone guard is ever consulted. Warning there would alarm every healthy
+    // Codex on the machine, and a warning that fires when nothing is wrong is how
+    // a real one stops being read.
+    const hasLiveQueue = (0, adapters_1.adapterFor)(s.runtime).queueMessage !== undefined;
+    if (!hasLiveQueue && s.ownerPid !== undefined && (0, parent_watch_1.processIsAlive)(s.ownerPid)) {
+        return "detached — NOTHING IS LISTENING, re-arm: the session is alive but its attach is gone (interrupted?), so a wake will be held, not resumed";
+    }
+    return s.resumeId ? "detached (headless resume ready)" : "detached (no resume id)";
+}
+/**
+ * One `relay status` session line.
+ *
+ * Exported so the rung's wording is testable: a fallback nobody can see in
+ * `status` is a silent fallback, which is the thing this transport must not be.
+ */
+function renderSessionLine(target, lastWakeFailure) {
+    return `  ${target.name}  [${target.runtime}]  ${sessionState(target, lastWakeFailure)}`;
+}
 async function cmdRelayAttach(opts) {
     if (!(0, adapters_1.isKnownRuntime)(opts.runtime)) {
         console.log(`unknown runtime "${opts.runtime}" — expected one of: ${adapters_1.KNOWN_RUNTIMES.join(", ")}`);
         return 1;
     }
     const runtime = opts.runtime;
+    // An explicit BAYCHAT_<RUNTIME>_BIN is a user ASSERTION, not a hint: they have
+    // told us which binary this session runs under. If it cannot be proven, the
+    // only honest move is to stop. Recording `runtimeBin: undefined` and attaching
+    // anyway looks like success and hands the daemon back exactly the guess this
+    // setting exists to prevent — which is how a confined snap `codex` came to be
+    // spawned for an npm session and every wake died "no rollout found".
+    // Probed ONCE, here, and carried to whichever transport wins below.
+    const runtimeBin = decideRuntimeBin(runtime);
+    if (!runtimeBin.ok) {
+        console.log(`BAYCHAT_${runtime.toUpperCase()}_BIN is set but unusable: ${runtimeBin.reason}`);
+        console.log("Not attaching. Fix it or unset it — nothing was registered, so the relay will not report this session as reachable.");
+        return 1;
+    }
     const resume = await resolveAttachResumeId(runtime, opts.resumeId, opts.discovery);
-    let sock;
-    try {
-        sock = await connectOrFail();
+    const sockPath = (0, socket_1.socketPath)();
+    const probe = await (0, socket_1.probeSocketDetailed)(sockPath);
+    if (shouldFallBackToMailbox(probe)) {
+        console.log(`Relay socket refused (${probe.alive ? "" : (probe.code ?? "denied")}) — this session is sandboxed.`);
+        console.log("Falling back to a mailbox FIFO, which a sandbox permits. `relay status` will show this session as attached (fifo).");
+        return attachViaMailbox({
+            session: opts.session,
+            runtime,
+            resume,
+            runtimeBin: runtimeBin.bin,
+            ownerPid: opts.ownerPid,
+            // Honoured on BOTH transports now. It was socket-only, which made
+            // `--timeout 30` a no-op precisely where a sandboxed session needs it.
+            timeoutMs: opts.timeoutMs,
+        });
     }
-    catch (err) {
-        console.log(err instanceof Error ? err.message : String(err));
+    if (!probe.alive) {
+        console.log((0, socket_1.describeProbeFailure)(sockPath, probe));
         return 1;
     }
+    const sock = net.createConnection(sockPath);
     return new Promise((resolve) => {
         const timer = opts.timeoutMs
             ? setTimeout(() => {
@@ -288,6 +625,19 @@ async function cmdRelayAttach(opts) {
                 resolve(2);
             }, opts.timeoutMs)
             : undefined;
+        // An attach outlives nothing. When the session that launched it goes away,
+        // this process must go with it — otherwise it keeps the socket open, the
+        // daemon keeps believing the session is live, and the next wake is written
+        // into a corpse and recorded as delivered. See ./parent-watch.ts.
+        const parentWatch = (0, parent_watch_2.watchParent)(process.ppid, () => {
+            console.log("Session that started this attach has exited — detaching so the relay stops treating it as live.");
+            sock.end();
+            resolve(3);
+        });
+        const settle = (code) => {
+            parentWatch.stop();
+            resolve(code);
+        };
         sock.on("data", (0, socket_1.createFrameReader)((frame) => {
             if (frame.type === "attached") {
                 console.log(`Attached as "${frame.session}". Waiting for messages…`);
@@ -302,7 +652,7 @@ async function cmdRelayAttach(opts) {
                     console.log(`  (${m.id}) ${m.senderType} ${m.senderId}${flag}: ${m.content}`);
                 }
                 sock.end();
-                resolve(0);
+                settle(0);
                 return;
             }
             if (frame.type === "error") {
@@ -310,19 +660,19 @@ async function cmdRelayAttach(opts) {
                     clearTimeout(timer);
                 console.log(frame.message);
                 sock.end();
-                resolve(1);
+                settle(1);
             }
         }));
         sock.on("error", (err) => {
             if (timer)
                 clearTimeout(timer);
             console.log(err.message);
-            resolve(1);
+            settle(1);
         });
         sock.on("close", () => {
             if (timer)
                 clearTimeout(timer);
-            resolve(2);
+            settle(2);
         });
         (0, socket_1.writeFrame)(sock, {
             type: "attach",
@@ -333,9 +683,12 @@ async function cmdRelayAttach(opts) {
             resumeEvidence: resume.ok ? resume.evidence : undefined,
             resumeCwd: resume.ok ? resume.cwd : undefined,
             cwd: process.cwd(),
-            // Resolved HERE, inside the session, because this is the only process that
-            // can answer it correctly — see SessionTarget.runtimeBin.
-            runtimeBin: resolveRuntimeBin(runtime),
+            // Decided once above, not re-probed here — see `decideRuntimeBin`.
+            runtimeBin: runtimeBin.bin,
+            // See SessionTarget.ownerPid: the runtime process that owns this session —
+            // found by walking past the launching shell, which does not outlive the
+            // wake and so cannot witness anything.
+            ownerPid: opts.ownerPid ?? (0, owner_pid_1.currentOwnerPid)(runtime),
         });
     });
 }
@@ -359,25 +712,76 @@ async function cmdRelayAttach(opts) {
  * machine where PATH is fine keeps working, and one where it is not now works too.
  */
 function resolveRuntimeBin(runtime) {
-    const dirs = (process.env.PATH ?? "").split(path.delimiter).filter(Boolean);
-    for (const dir of dirs) {
-        const candidate = path.join(dir, runtime);
-        try {
-            // X_OK, not existsSync: a same-named directory or an unreadable file on PATH
-            // must not be recorded as the binary, or the recorded path is worse than the
-            // bare name it replaced.
-            fs.accessSync(candidate, fs.constants.X_OK);
-            // Resolve symlinks: ~/.local/bin/claude is typically a link into a versioned
-            // directory, and recording the link means a later version bump silently
-            // repoints every wake. The real path is what this session is actually running.
-            return fs.realpathSync(candidate);
-        }
-        catch {
-            // Not here; keep looking. No logging — a PATH entry that does not hold the
-            // binary is the normal case, not a problem.
-        }
+    // Delegates to the prover rather than walking PATH itself. The hand-rolled
+    // walk this replaces had two Windows faults, and both produced a recorded
+    // path the daemon could never spawn:
+    //
+    //   • it joined the BARE name onto each PATH entry, so it never considered
+    //     `codex.cmd` — and every npm-installed CLI on Windows IS a .cmd shim;
+    //   • it accepted a candidate on `fs.accessSync(X_OK)`, which Windows has no
+    //     execute bit to answer, so any readable file passes. The extensionless
+    //     `codex` — an sh script, unrunnable there — sailed through.
+    //
+    // Observed 2026-08-30: runtimeBin recorded as
+    // `C:\Users\…\npm\codex`, and the wake died with `spawn … ENOENT`.
+    //
+    // `resolveRuntimeBinary` tries the platform's real extension order and PROVES
+    // each candidate by running it, which is the same question this function was
+    // always asking — just answered correctly.
+    const decided = decideRuntimeBin(runtime);
+    return decided.ok ? decided.bin : undefined;
+}
+/**
+ * What to record for this runtime, or why the attach must not proceed.
+ *
+ * ONE probe, and the caller carries the answer. `resolveRuntimeBinary` SPAWNS
+ * each candidate to prove it, so asking twice is not merely wasteful: the second
+ * answer can differ from the first. An attach that passed the override guard and
+ * then re-probed could still register `runtimeBin: undefined` — the exact state
+ * the guard exists to prevent, reached by way of the guard.
+ */
+function decideRuntimeBin(runtime) {
+    const override = process.env[`BAYCHAT_${runtime.toUpperCase()}_BIN`];
+    const resolved = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)(override));
+    if (!resolved.ok) {
+        // An explicit override is a user ASSERTION. If it cannot be proven, stop —
+        // see the guard in `cmdRelayAttach`. Absence of one is not an assertion, so
+        // a plain failed probe keeps the best-effort fallback.
+        if (override)
+            return { ok: false, reason: (0, runtime_binary_1.summarizeResolutionFailure)(resolved) };
+        return { ok: true, bin: managedRuntimeBin(runtime) };
+    }
+    try {
+        // Resolve symlinks: ~/.local/bin/claude is typically a link into a versioned
+        // directory, and recording the link means a later version bump silently
+        // repoints every wake. The real path is what this session is actually running.
+        return { ok: true, bin: fs.realpathSync(resolved.path) };
+    }
+    catch {
+        // A path we just ran but cannot realpath is still the right answer.
+        return { ok: true, bin: resolved.path };
+    }
+}
+function managedRuntimeBin(runtime) {
+    if (runtime !== "codex")
+        return undefined;
+    const root = process.env.CODEX_MANAGED_PACKAGE_ROOT?.trim();
+    if (!root)
+        return undefined;
+    const candidate = path.join(root, "bin", "codex.js");
+    // PROVEN, not assumed. `statSync().isFile()` was the whole check here, so any
+    // file at that path counted — including one that cannot be spawned. Recording
+    // an unrunnable path is the failure this fallback exists to prevent, so it is
+    // put through the same prover an override gets: spawn it, ask its version.
+    const proved = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)(candidate));
+    if (!proved.ok)
+        return undefined;
+    try {
+        return fs.realpathSync(proved.path);
+    }
+    catch {
+        return proved.path;
     }
-    return undefined;
 }
 /**
  * Decide what resume id this attach registers, and say so out loud.