baychat 0.13.1 → 0.14.0

package/dist/index.js

@@ -3,11 +3,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const commands_1 = require("./commands");
 const approve_hook_1 = require("./approve-hook");
+const doctor_command_1 = require("./doctor-command");
 const connect_1 = require("./connect");
 const mcp_1 = require("./mcp");
 const mcp_config_1 = require("./mcp-config");
 const commands_2 = require("./relay/commands");
 const help_topics_1 = require("./help-topics");
+const args_1 = require("./args");
 const HELP = `baychat — BayChat connector CLI for agent sessions (Claude Code, Codex)
 
 Usage:
@@ -83,6 +85,14 @@ Usage:
                                         came from, so "we can wake this headlessly"
                                         is a claim you can check
   baychat relay stop                    Stop the relay and disable it at boot
+  baychat doctor [--json]               Check every link between this machine and
+                                        BayChat — credential, relay, and per runtime
+                                        its MCP registration, skill, executable and
+                                        live session — and print exactly what to type
+                                        for each thing that is wrong. Exit 0 clear,
+                                        1 broken, 2 messages nothing answered.
+                                        --json emits the same report as data, for
+                                        pasting into a support thread
   baychat approve-hook [--session <name>] [--timeout <sec>]
                                         Claude Code PermissionRequest hook: send the
                                         permission prompt to BayChat as a decision card
@@ -108,46 +118,45 @@ Usage:
 Connect flow: in BayChat, open the agent -> Connect -> copy the pairing code,
 then run \`baychat pair <code>\`. Pairing rotates the agent token; use a
 dedicated agent per session.`;
-function flag(args, name) {
-    const i = args.indexOf(name);
-    return i >= 0 && i + 1 < args.length ? args[i + 1] : undefined;
-}
-/** The first positional (non `--flag`) argument, so a command's id isn't shadowed
- * by a leading boolean flag like `--catch-up`/`--refresh`. */
-function positional(args) {
-    return args.find((a) => !a.startsWith("--"));
-}
 /** Drop a `--name <value>` pair, so a multi-word positional (a search query)
- * doesn't swallow the flag's value as part of itself. */
+ * doesn't swallow the flag's value as part of itself.
+ *
+ * Only the flag is dropped when its value is missing — the next token is
+ * another option, or there is none. Consuming two entries there would eat an
+ * unrelated argument, the same mistake `flag` refuses to make. */
 function withoutFlag(args, name) {
     const i = args.indexOf(name);
-    return i < 0 ? args : [...args.slice(0, i), ...args.slice(i + 2)];
+    if (i < 0)
+        return args;
+    const next = args[i + 1];
+    const consumed = next !== undefined && !next.startsWith("--") ? 2 : 1;
+    return [...args.slice(0, i), ...args.slice(i + consumed)];
 }
 /** A flag's value as a number, or undefined when absent. A non-numeric value
  * becomes NaN and is rejected by the tool's own bounds check with a message
  * that names the field. */
 function numberFlag(args, name) {
-    const raw = flag(args, name);
+    const raw = (0, args_1.flag)(args, name);
     return raw === undefined ? undefined : Number(raw);
 }
 async function main() {
     const [command, ...args] = process.argv.slice(2);
     switch (command) {
         case "onboard":
-            await (0, commands_1.cmdOnboard)(positional(args), { catchUp: args.includes("--catch-up") });
+            await (0, commands_1.cmdOnboard)((0, args_1.positional)(args), { catchUp: args.includes("--catch-up") });
             return 0;
         case "login": {
-            const loggedIn = await (0, commands_1.cmdLogin)({ base: flag(args, "--base"), token: flag(args, "--token") });
+            const loggedIn = await (0, commands_1.cmdLogin)({ base: (0, args_1.flag)(args, "--base"), token: (0, args_1.flag)(args, "--token") });
             return loggedIn ? 0 : 2; // 2 = the link request expired without approval
         }
         case "pair": {
             if (!args[0])
                 throw new Error("Usage: baychat pair <code>");
-            await (0, commands_1.cmdPair)(args[0], flag(args, "--base"));
+            await (0, commands_1.cmdPair)(args[0], (0, args_1.flag)(args, "--base"));
             return 0;
         }
         case "link": {
-            const linked = await (0, commands_1.cmdLink)({ name: flag(args, "--name"), base: flag(args, "--base") });
+            const linked = await (0, commands_1.cmdLink)({ name: (0, args_1.flag)(args, "--name"), base: (0, args_1.flag)(args, "--base") });
             return linked ? 0 : 2;
         }
         case "qr":
@@ -209,7 +218,7 @@ async function main() {
             return 0;
         }
         case "summary": {
-            const conversationId = positional(args);
+            const conversationId = (0, args_1.positional)(args);
             if (!conversationId)
                 throw new Error("Usage: baychat summary <conversationId> [--refresh]");
             await (0, commands_1.cmdSummary)(conversationId, { refresh: args.includes("--refresh") });
@@ -223,7 +232,7 @@ async function main() {
             return 0;
         }
         case "fetch": {
-            const url = positional(withoutFlag(args, "--max-chars"));
+            const url = (0, args_1.positional)(withoutFlag(args, "--max-chars"));
             if (!url)
                 throw new Error("Usage: baychat fetch <url> [--max-chars <n>]");
             await (0, commands_1.cmdFetch)(url, { maxChars: numberFlag(args, "--max-chars") });
@@ -232,8 +241,8 @@ async function main() {
         case "watch": {
             if (!args[0])
                 throw new Error("Usage: baychat watch <conversationId>");
-            const intervalSec = Number(flag(args, "--interval") ?? "5");
-            const timeoutSec = Number(flag(args, "--timeout") ?? "300");
+            const intervalSec = Number((0, args_1.flag)(args, "--interval") ?? "5");
+            const timeoutSec = Number((0, args_1.flag)(args, "--timeout") ?? "300");
             const got = await (0, commands_1.cmdWatch)(args[0], {
                 intervalMs: intervalSec * 1000,
                 timeoutMs: timeoutSec * 1000,
@@ -241,7 +250,7 @@ async function main() {
             return got ? 0 : 2;
         }
         case "relay": {
-            const sub = positional(args) ?? "";
+            const sub = (0, args_1.positional)(args) ?? "";
             const rest = args.filter((a) => a !== sub);
             switch (sub) {
                 case "start":
@@ -252,15 +261,15 @@ async function main() {
                 case "stop":
                     return await (0, commands_2.cmdRelayStop)();
                 case "attach": {
-                    const session = flag(rest, "--session");
+                    const session = (0, args_1.flag)(rest, "--session");
                     if (!session) {
                         throw new Error("Usage: baychat relay attach --session <name> [--runtime claude|codex|hermes] [--resume-id <id>] [--timeout <sec>]");
                     }
                     const timeoutSec = numberFlag(rest, "--timeout");
                     return await (0, commands_2.cmdRelayAttach)({
                         session,
-                        runtime: flag(rest, "--runtime") ?? "claude",
-                        resumeId: flag(rest, "--resume-id"),
+                        runtime: (0, args_1.flag)(rest, "--runtime") ?? "claude",
+                        resumeId: (0, args_1.flag)(rest, "--resume-id"),
                         timeoutMs: timeoutSec ? timeoutSec * 1000 : undefined,
                     });
                 }
@@ -274,15 +283,20 @@ async function main() {
             // exit-1 hook with no JSON on stdout is a NON-BLOCKING error: the tool call proceeds. The
             // guard in the catch below covers that anyway.
             return await (0, approve_hook_1.cmdApproveHook)(args);
+        case "doctor":
+            // Deliberately placed with the setup commands: it is the thing you run
+            // when one of them did not take, and the one command that inspects all
+            // of them at once.
+            return await (0, doctor_command_1.cmdDoctor)(args);
         case "connect": {
             // A bare `connect` prints the client menu; positional() skips a leading flag
             // so `connect --base x codex` still finds the client.
-            return await (0, connect_1.cmdConnect)(positional(args), { base: flag(args, "--base") });
+            return await (0, connect_1.cmdConnect)((0, args_1.positional)(args), { base: (0, args_1.flag)(args, "--base") });
         }
         case "mcp-config": {
             // `--client` with no value is a typo, not a request for the menu: pass the
             // empty string so it is rejected by name rather than silently listing.
-            (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? (flag(args, "--client") ?? "") : undefined);
+            (0, mcp_config_1.cmdMcpConfig)(args.includes("--client") ? ((0, args_1.flag)(args, "--client") ?? "") : undefined);
             return 0;
         }
         case "mcp": {

package/dist/relay/adapters.js

@@ -7,7 +7,10 @@ exports.isKnownRuntime = isKnownRuntime;
 exports.runHeadless = runHeadless;
 const child_process_1 = require("child_process");
 const attachments_1 = require("../attachments");
+const codex_app_server_1 = require("./codex-app-server");
+const codex_queue_1 = require("./codex-queue");
 const resume_1 = require("./resume");
+const spawn_env_1 = require("./spawn-env");
 /** How long a headless turn may run before the relay gives up on it. */
 const HEADLESS_TIMEOUT_MS = 10 * 60_000;
 /**
@@ -18,7 +21,7 @@ const HEADLESS_TIMEOUT_MS = 10 * 60_000;
  * relay carries the message and nothing more. Telling a resumed turn to "answer
  * this" would route around the room's reply policy from outside the room.
  */
-function buildWakePrompt(session, conversationId, batch) {
+function buildWakePrompt(session, conversationId, batch, reArm) {
     const lines = [];
     for (const m of batch) {
         const flag = m.shouldRespond ? " [shouldRespond=true]" : "";
@@ -40,8 +43,47 @@ function buildWakePrompt(session, conversationId, batch) {
         ...lines,
         "",
         `Re-read the room with the BayChat tools (session="${session}") before acting. Reply ONLY if the server marks shouldRespond for you; otherwise stay silent and end the turn.`,
+        ...reArmLines(session, reArm),
     ].join("\n");
 }
+/**
+ * How this session gets woken a SECOND time.
+ *
+ * A headless resume is spawned by the daemon, so it inherits the daemon's
+ * environment — and under systemd that PATH contains neither `node` nor
+ * `baychat` nor the runtime itself. The installed skill tells a woken session to
+ * re-arm with a bare `baychat relay attach`, which a resumed session cannot run:
+ * command not found. It answers once and then goes quiet forever, which is
+ * precisely the failure re-arming exists to prevent — and it looks like the
+ * model forgetting rather than like us handing it an impossible instruction.
+ *
+ * So the daemon, which knows both absolute paths because it IS them, spells the
+ * command out. Omitted entirely when the caller has no paths to offer, rather
+ * than printed with holes in it.
+ */
+function reArmLines(session, reArm) {
+    if (!reArm)
+        return [];
+    const command = `  ${reArm.node} ${reArm.cli} relay attach --session "${session}" --runtime ${reArm.runtime}`;
+    if (reArm.transport === "fifo") {
+        return [
+            "",
+            "To stay reachable, run this IN THE FOREGROUND before ending your turn. It",
+            "blocks until a message arrives, prints it, and exits — that exit is the wake.",
+            "Do NOT put it in the background: your sandbox kills backgrounded processes",
+            "when the command returns, so a backgrounded attach listens to nothing while",
+            "looking like it worked.",
+            command,
+        ];
+    }
+    return [
+        "",
+        "To stay reachable, run this in the BACKGROUND before ending your turn. It is",
+        "written with absolute paths because a resumed session's PATH may not contain",
+        "node or baychat at all:",
+        command,
+    ];
+}
 /**
  * One attachment line for the wake prompt: what it is, then how to fetch it.
  *
@@ -91,6 +133,19 @@ const claudeAdapter = {
 };
 const codexAdapter = {
     runtime: "codex",
+    queueMessage({ binaryPath, target, message }) {
+        // `codex queue` landed in 0.149.0. Delivering here rather than through the
+        // headless spawn is what lets a woken Codex actually REPLY: the message goes
+        // to the live session, where the human is present to approve, instead of a
+        // separate turn that must run `approvalPolicy: "never"` and is therefore
+        // blocked from calling BayChat's write tools at all.
+        return (0, codex_queue_1.queueToThread)({
+            binaryPath,
+            threadId: target.resumeId,
+            message,
+            cwd: target.resumeCwd ?? target.cwd,
+        });
+    },
     canResume(target) {
         if (!target.resumeId) {
             return {
@@ -109,6 +164,29 @@ const codexAdapter = {
             args: ["exec", "resume", target.resumeId, prompt],
         };
     },
+    /**
+     * Prefer `codex app-server`, which can say what `codex exec` never could.
+     *
+     * `exec resume` reports only an exit code, so "the thread id names nothing on
+     * this machine", "the turn stopped at an approval" and "the model was
+     * unavailable" all arrive as `exited 1`. app-server distinguishes them, and
+     * the reason is what a user needs to act.
+     *
+     * Opting out with BAYCHAT_CODEX_TRANSPORT=exec is deliberate: the app-server
+     * interface is marked `[experimental]` by OpenAI and its shape is not frozen,
+     * so there has to be a way back that does not require a new release.
+     */
+    async runTurn({ binaryPath, target, prompt }) {
+        if (process.env.BAYCHAT_CODEX_TRANSPORT === "exec") {
+            return { kind: "failed", transportUnusable: true, reason: "BAYCHAT_CODEX_TRANSPORT=exec" };
+        }
+        return (0, codex_app_server_1.runCodexTurn)({
+            binaryPath,
+            threadId: target.resumeId,
+            prompt,
+            cwd: target.resumeCwd ?? target.cwd,
+        }, { spawn: child_process_1.spawn });
+    },
 };
 /**
  * Cursor can be woken, and cannot be resumed. Both halves matter.
@@ -200,6 +278,9 @@ function runHeadless(file, args, opts = {}) {
     return new Promise((resolve) => {
         const child = (0, child_process_1.spawn)(file, args, {
             cwd: opts.cwd,
+            // An npm-installed runtime is a script with a `#!/usr/bin/env node`
+            // shebang, and the daemon's systemd PATH has no node. See ./spawn-env.ts.
+            env: (0, spawn_env_1.headlessSpawnEnv)(),
             shell: false,
             stdio: ["ignore", "ignore", "pipe"],
             detached: false,

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] ?? "";
+}