baychat 0.13.0 → 0.14.0

package/dist/relay/codex-app-server.js

@@ -0,0 +1,217 @@
+"use strict";
+// Waking a Codex thread through `codex app-server` instead of `codex exec resume`.
+//
+// WHY. `codex exec resume <id> <prompt>` is a fire-and-forget process whose only
+// report is an exit code. It cannot say whether the turn answered, whether it
+// stopped at an approval, or whether the id even named a real thread — every one
+// of those is "exit non-zero", and the relay could only record DELIVERY PENDING
+// with a number in it.
+//
+// `codex app-server` is the JSON-RPC 2.0 interface behind OpenAI's own VS Code
+// and JetBrains plugins. It answers `thread/resume` for a specific id — with a
+// distinct error when that id is not a real thread — and reports the turn's end
+// as `turn/completed` rather than as a process exit. Verified against codex-cli
+// 0.114.0 on 2026-08-30: initialize → initialized → thread/resume → turn/start,
+// with the resumed thread's own MCP servers (BayChat included) started for it.
+//
+// ONE PROCESS PER WAKE, NOT A HELD CONNECTION. The design note for this work
+// proposed keeping one app-server alive for the daemon's life. That buys a little
+// latency and costs a supervision problem — restarts, health, a wedged child
+// holding every session's queue — for a path that runs at human speed anyway.
+// A process per wake keeps the failure modes identical to the ones `runHeadless`
+// already has, and every win that mattered (an id we address explicitly, a
+// structured turn result, no shell) survives.
+//
+// `approvalPolicy: "never"` IS THE SECURITY BOUNDARY. A headless turn has no
+// human to ask, so the only safe policy is one that never prompts and never
+// escalates: a command needing approval fails inside the sandbox instead of
+// running because a chat message asked for it. The relay carries messages; it
+// does not acquire privileges on their behalf.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCodexTurn = runCodexTurn;
+const runtime_binary_1 = require("../runtime-binary");
+const spawn_env_1 = require("./spawn-env");
+/** How long a whole wake may take — resume, turn, and completion. */
+const TURN_TIMEOUT_MS = 10 * 60_000;
+/** How long the handshake alone may take before we call the binary unusable. */
+const HANDSHAKE_TIMEOUT_MS = 30_000;
+/**
+ * Run one turn against an existing Codex thread and resolve with its outcome.
+ *
+ * Never throws and never rejects: every failure — a binary that will not start,
+ * a thread id that names nothing, a protocol error, a timeout — is a `failed`
+ * outcome carrying its reason. The caller's job is to record that, and a thrown
+ * exception would only turn a describable state into a stack trace.
+ */
+function runCodexTurn(req, deps) {
+    const spawn = deps.spawn;
+    const turnTimeout = deps.turnTimeoutMs ?? TURN_TIMEOUT_MS;
+    const handshakeTimeout = deps.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
+    return new Promise((resolve) => {
+        // A Windows .cmd needs its interpreter named, exactly as the plain-spawn
+        // path does. This was missed when that fix landed, and the result was
+        // `delivery failed for CodexTest: spawn EINVAL` on every wake — the
+        // transport failing before the handshake, on a machine where Codex was
+        // installed and working.
+        const plan = (0, runtime_binary_1.spawnPlanFor)(req.binaryPath, process.platform);
+        const child = spawn(plan.file, [...plan.prefixArgs, "app-server"], {
+            cwd: req.cwd,
+            // Same reason as `runHeadless`: an npm-installed codex is a script with a
+            // `#!/usr/bin/env node` shebang and the daemon's PATH has no node. Both
+            // spawn sites need this — fixing only one leaves the other dying with
+            // exit 127 the moment it becomes the reachable path.
+            env: (0, spawn_env_1.headlessSpawnEnv)(),
+            // No shell, ever: the prompt carries message text written by other people
+            // in the room, and a shell string would make `$(…)` in a chat message run
+            // on this box. Nothing here is concatenated into a command line.
+            shell: false,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let settled = false;
+        let nextId = 0;
+        const pending = new Map();
+        let stdoutBuffer = "";
+        let stderrTail = "";
+        /** Resolve once, and always leave no process behind. */
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill("SIGTERM");
+            // A child that ignores the polite signal would otherwise outlive the relay
+            // and keep answering a room nobody is watching.
+            setTimeout(() => child.kill("SIGKILL"), 5_000).unref();
+            resolve(outcome);
+        };
+        let timer = setTimeout(() => finish({ kind: "failed", transportUnusable: true, reason: `codex app-server did not complete the handshake within ${Math.round(handshakeTimeout / 1000)}s` }), handshakeTimeout);
+        const request = (method, params) => new Promise((res) => {
+            const id = nextId++;
+            pending.set(id, res);
+            child.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+        });
+        const notify = (method, params) => {
+            child.stdin?.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+        };
+        child.stdout?.on("data", (chunk) => {
+            stdoutBuffer += chunk.toString();
+            // Newline-delimited JSON. A partial line is kept for the next chunk;
+            // parsing one would be the classic framing bug.
+            let newline = stdoutBuffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = stdoutBuffer.slice(0, newline).trim();
+                stdoutBuffer = stdoutBuffer.slice(newline + 1);
+                newline = stdoutBuffer.indexOf("\n");
+                if (line === "")
+                    continue;
+                let message;
+                try {
+                    message = JSON.parse(line);
+                }
+                catch {
+                    // Not our protocol. Ignored rather than fatal: the binary is entitled
+                    // to print things, and a stray line must not lose a turn that is
+                    // otherwise proceeding normally.
+                    continue;
+                }
+                if (typeof message.id === "number" && pending.has(message.id)) {
+                    const waiting = pending.get(message.id);
+                    pending.delete(message.id);
+                    waiting?.(message);
+                    continue;
+                }
+                // `turn/completed` is the end of the wake — the whole reason this
+                // transport is better than an exit code.
+                if (message.method === "turn/completed")
+                    finish({ kind: "completed" });
+            }
+        });
+        child.stderr?.on("data", (chunk) => {
+            // Bounded, and kept only to explain a failure. Codex logs freely here even
+            // on a healthy run, so it is never treated as a failure signal by itself.
+            const text = chunk.toString();
+            stderrTail = `${stderrTail}${text}`.slice(-2_000);
+        });
+        child.on("error", (err) => {
+            finish({ kind: "failed", transportUnusable: true, reason: `could not start codex app-server: ${err.message}` });
+        });
+        child.on("close", (code) => {
+            // Only meaningful if we have not already completed: an expected exit
+            // follows our own SIGTERM.
+            finish({
+                kind: "failed",
+                // Dying before the turn completed means the transport did not work,
+                // whatever the cause — worth one attempt down the older path.
+                transportUnusable: true,
+                reason: `codex app-server exited ${code ?? "on a signal"} before the turn completed${firstLine(stderrTail)}`,
+            });
+        });
+        void (async () => {
+            const initialized = await request("initialize", {
+                clientInfo: { name: "baychat-relay", title: "BayChat relay", version: CLIENT_VERSION },
+            });
+            if (initialized.error) {
+                finish({ kind: "failed", transportUnusable: true, reason: `codex app-server refused the handshake: ${initialized.error.message}` });
+                return;
+            }
+            notify("initialized", {});
+            const resumed = await request("thread/resume", {
+                threadId: req.threadId,
+                cwd: req.cwd,
+                // See the file header: no human is present, so nothing may be approved.
+                approvalPolicy: "never",
+            });
+            if (resumed.error) {
+                // "already has an active writer" is not a fault — it is the interactive
+                // session being OPEN. A thread being written by a live Codex TUI cannot
+                // also be resumed from outside it, and that is the correct behaviour:
+                // two writers on one thread is the failure mode, not the refusal.
+                //
+                // It also names the remedy exactly. A live session is reachable through
+                // its `relay attach`, which is what attach is FOR; headless resume is
+                // for a session whose terminal has gone. Saying "could not resume" and
+                // stopping there sends someone hunting for a break that is not there.
+                if (/active writer/i.test(resumed.error.message)) {
+                    finish({
+                        kind: "failed",
+                        transportUnusable: false,
+                        reason: `Codex session "${req.threadId}" is open in a terminal, so it cannot be resumed from ` +
+                            `outside it — a live session is woken through \`baychat relay attach\`, which must be ` +
+                            `running in that session. Close the terminal to make it headlessly resumable instead.`,
+                    });
+                    return;
+                }
+                // The distinct failure `exec resume` could never report: the id does not
+                // name a thread on this machine. Worth saying plainly, because the usual
+                // cause is a Codex whose sessions live somewhere else — a snap install
+                // keeps them under ~/snap/codex/current/sessions.
+                finish({ kind: "failed", transportUnusable: false, reason: `codex could not resume thread ${req.threadId}: ${resumed.error.message}` });
+                return;
+            }
+            // The handshake is done; the clock is now the turn's, which is far longer.
+            clearTimeout(timer);
+            timer = setTimeout(() => finish({ kind: "failed", transportUnusable: false, reason: `codex turn did not complete within ${Math.round(turnTimeout / 60_000)} minutes` }), turnTimeout);
+            const started = await request("turn/start", {
+                threadId: req.threadId,
+                input: [{ type: "text", text: req.prompt }],
+                approvalPolicy: "never",
+            });
+            if (started.error) {
+                finish({ kind: "failed", transportUnusable: false, reason: `codex refused the turn: ${started.error.message}` });
+            }
+            // Success is NOT the response to turn/start — that only says the turn was
+            // accepted. The wake ends at the `turn/completed` notification, handled above.
+        })();
+    });
+}
+/** Reported to Codex as the client version. Kept in step with the package. */
+const CLIENT_VERSION = "0.12.0";
+/** One line of captured stderr, for appending to a failure reason. */
+function firstLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed !== "")
+            return `: ${trimmed.slice(0, 200)}`;
+    }
+    return "";
+}

package/dist/relay/codex-queue.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queueToThread = queueToThread;
+const child_process_1 = require("child_process");
+const runtime_binary_1 = require("../runtime-binary");
+const spawn_env_1 = require("./spawn-env");
+/** How long `codex queue` may take before we treat it as unusable. */
+const QUEUE_TIMEOUT_MS = 30_000;
+/**
+ * Deliver a message to a Codex session through Codex's own queue.
+ *
+ * WHY THIS IS THE RIGHT PATH, and better than every rung it sits above.
+ *
+ * The relay's other options all fight the runtime. A socket attach is refused
+ * inside a sandbox; a FIFO reaches a process but nothing re-invokes the agent;
+ * a headless resume starts a SEPARATE turn with no human, which is why it must
+ * run `approvalPolicy: "never"` — and that policy blocks Codex's own BayChat
+ * write path, so a headlessly-woken Codex can read the room and never answer it.
+ * Observed 2026-08-31 00:09 in Codex's own words: "BayChat's write path is
+ * unavailable under the enforced no-approval policy."
+ *
+ * `codex queue` sidesteps all of it. The message goes to the LIVE session, where
+ * the human already is, so approvals work normally and the relay never has to
+ * acquire a privilege on a chat message's behalf. It is first-party, needs no
+ * pty, injects nothing into a terminal, and queues when the session is between
+ * turns rather than being lost.
+ *
+ * Requires Codex >= 0.149.0, which is where `queue` landed. An older build is
+ * reported `unsupported` so the caller drops to the spawn, exactly as `runTurn`
+ * does with `transportUnusable`.
+ *
+ * argv array, never a shell string: the message is text written by other people
+ * in the room, and a shell would make `$(…)` in a chat message run on this box.
+ */
+function queueToThread(input) {
+    const runner = input.run ?? child_process_1.execFile;
+    // Node cannot spawn a `.cmd` directly — it fails EINVAL — so on Windows the
+    // interpreter is named explicitly. NEVER `shell: true`: the message is text
+    // written by other people in the room, and a shell string would make `$(…)`
+    // in a chat message run on this box.
+    const plan = (0, runtime_binary_1.spawnPlanFor)(input.binaryPath, input.platform ?? process.platform);
+    return new Promise((resolve) => {
+        runner(plan.file, [...plan.prefixArgs, "queue", "--thread", input.threadId, "--message", input.message], {
+            cwd: input.cwd,
+            env: (0, spawn_env_1.headlessSpawnEnv)(),
+            timeout: input.timeoutMs ?? QUEUE_TIMEOUT_MS,
+            maxBuffer: 1024 * 1024,
+        }, (err, stdout, stderr) => {
+            const out = `${stdout ?? ""}${stderr ?? ""}`;
+            if (!err) {
+                // "Queued message <uuid> for thread <uuid>." — kept as evidence, the
+                // same way a resume id carries the evidence it was learned with.
+                const id = /Queued message ([0-9a-fA-F-]{8,})/.exec(out)?.[1];
+                return resolve({ kind: "queued", messageId: id });
+            }
+            // An older Codex has no `queue` subcommand. clap says so on stderr, and
+            // it is a statement about the BUILD, not about this session — so the
+            // caller may still try the rung below.
+            if (/unrecognized subcommand|unexpected argument|error: unknown/i.test(out)) {
+                return resolve({ kind: "unsupported", reason: `this codex build has no \`queue\` subcommand: ${firstLine(out)}` });
+            }
+            resolve({ kind: "failed", reason: firstLine(out) || err.message });
+        });
+    });
+}
+function firstLine(text) {
+    return text.split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? "";
+}

package/dist/relay/commands.js

@@ -35,26 +35,36 @@ 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;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
-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 daemon_1 = require("./daemon");
 const resume_1 = require("./resume");
+const mailbox_1 = require("./mailbox");
 const socket_1 = require("./socket");
+const parent_watch_1 = 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 +175,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 {
@@ -184,7 +214,7 @@ async function cmdRelayStatus() {
         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);
         console.log(`  ${s.name}  [${s.runtime}]  ${state}`);
         console.log(`     ${resumeLabel(s)}`);
     }
@@ -265,6 +295,94 @@ 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 HERE, 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.
+        runtimeBin: resolveRuntimeBin(opts.runtime),
+        fifo,
+        pid: process.pid,
+        registeredAt: new Date().toISOString(),
+    });
+    await (0, mailbox_1.awaitWakeFifo)(fifo);
+    console.log(`Attached as "${opts.session}" over a mailbox FIFO (${fifo}). Waiting for messages…`);
+    // Opening for read blocks until the daemon opens for write. That block IS the
+    // wait, and it costs nothing: no model is running while it holds.
+    const raw = await fs.promises.readFile(fifo, "utf8");
+    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;
+}
+/** The state half of one `relay status` session line. */
+function sessionState(s) {
+    // "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.
+    if (s.attached)
+        return s.transport === "fifo" ? "registered (fifo)" : "attached";
+    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) {
+    return `  ${target.name}  [${target.runtime}]  ${sessionState(target)}`;
+}
 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(", ")}`);
@@ -272,14 +390,18 @@ async function cmdRelayAttach(opts) {
     }
     const runtime = opts.runtime;
     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 });
     }
-    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 +410,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_1.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 +437,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 +445,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",
@@ -359,25 +494,36 @@ 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 override = process.env[`BAYCHAT_${runtime.toUpperCase()}_BIN`];
+    const resolved = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)(override));
+    if (!resolved.ok)
+        return undefined;
+    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 fs.realpathSync(resolved.path);
+    }
+    catch {
+        // A path we just ran but cannot realpath is still the right answer.
+        return resolved.path;
     }
-    return undefined;
 }
 /**
  * Decide what resume id this attach registers, and say so out loud.