baychat 0.20.0 → 0.20.1

package/README.md

@@ -30,7 +30,7 @@ Coding sessions show idle after five minutes without use and expire after
 24 hours. `end_session` closes one immediately. History survives and the same
 name can rejoin. Persistent agents such as Hermes keep their own lifecycle.
 
-This workflow requires CLI 0.20.0 and its matching API deployment. Update npm,
+This workflow requires CLI 0.20.1 and the existing session-chat API deployment. Update npm,
 rerun `baychat connect <runtime>` to refresh its skill, and restart running
 relays and MCP clients. Updating npm alone does not deploy the remote MCP.
 
@@ -49,10 +49,17 @@ baychat join --group "Coding" --runtime codex
 ```
 
 It joins through remote MCP, uses the server-confirmed identity, checks the relay
-and attaches incoming messages. Claude runs this command with its persistent
-Monitor and re-arms automatically after a wake. Codex uses a bounded foreground
-attach to register its verified native identity. Failed delivery setup is reported
-as incomplete, even when the room join succeeded.
+and connects incoming messages. Claude runs this command with its persistent
+Monitor and re-arms automatically after a wake. Codex verifies native queue
+support and returns as soon as the relay confirms registration. It needs no
+waiting terminal or manual re-arming. Failed delivery setup is reported as
+incomplete, even when the room join succeeded.
+
+The Windows relay runs without a visible console, including after login and
+network reconnects. Incoming messages appear as `@Sender` in the coding task.
+The skill echoes BayChat chat replies locally; raw tool output stays local.
+Codex can queue messages behind an active turn, so an accepted message is not
+proof of an immediate reply.
 
 For a persistent Hermes installation, run this on the Hermes machine:
 

package/dist/relay/adapters.js

@@ -197,7 +197,11 @@ const codexAdapter = {
      */
     async runTurn({ binaryPath, target, prompt }) {
         if (process.env.BAYCHAT_CODEX_TRANSPORT === "exec") {
-            return { kind: "failed", transportUnusable: true, reason: "BAYCHAT_CODEX_TRANSPORT=exec" };
+            return {
+                kind: "failed",
+                transportUnusable: true,
+                reason: "BAYCHAT_CODEX_TRANSPORT=exec",
+            };
         }
         return (0, codex_app_server_1.runCodexTurn)({
             binaryPath,
@@ -234,7 +238,10 @@ const cursorAdapter = {
         // Nothing to discover: Cursor writes no on-disk session state this package
         // can identify a conversation from, and a search that cannot succeed is
         // only a way to produce a confident-looking wrong answer.
-        return { ok: false, reason: "Cursor records no resumable session id on this machine" };
+        return {
+            ok: false,
+            reason: "Cursor records no resumable session id on this machine",
+        };
     },
     headlessCommand() {
         // Unreachable: the daemon consults canResume first and reports pending.
@@ -259,7 +266,10 @@ const hermesAdapter = {
     async discoverResume() {
         // Nothing to discover: Hermes runs somewhere else and leaves no local
         // transcript. Searching would only produce a confident-looking wrong answer.
-        return { ok: false, reason: "Hermes keeps no local session state on this machine" };
+        return {
+            ok: false,
+            reason: "Hermes keeps no local session state on this machine",
+        };
     },
     headlessCommand() {
         // Unreachable: the daemon consults canResume first and reports pending.
@@ -317,7 +327,9 @@ function profileAdapter(profile) {
             // `session-name` runtimes are resumed by the name the human chose, which
             // IS the BayChat session name — so there is nothing to discover and
             // nothing that could name someone else's session.
-            const id = profile.sessionId.kind === "session-name" ? target.name : target.resumeId;
+            const id = profile.sessionId.kind === "session-name"
+                ? target.name
+                : target.resumeId;
             if (!id) {
                 return {
                     ok: false,
@@ -337,7 +349,9 @@ function profileAdapter(profile) {
         headlessCommand(target, prompt) {
             if (!profile.headless)
                 throw new Error(`${profile.id} has no headless command`);
-            const id = profile.sessionId.kind === "session-name" ? target.name : target.resumeId;
+            const id = profile.sessionId.kind === "session-name"
+                ? target.name
+                : target.resumeId;
             return {
                 file: target.runtimeBin ?? profile.bin,
                 args: (0, profiles_1.fillTemplate)(profile.headless.args, { id, prompt }),
@@ -353,7 +367,10 @@ function adapterFor(runtime) {
     return profile ? profileAdapter(profile) : unknownAdapter(runtime);
 }
 /** The runtimes we ship knowledge of, for help text. NOT a list of what is accepted. */
-exports.KNOWN_RUNTIMES = [...Object.keys(ADAPTERS), ...profiles_1.RUNTIME_PROFILES.map((p) => p.id)];
+exports.KNOWN_RUNTIMES = [
+    ...Object.keys(ADAPTERS),
+    ...profiles_1.RUNTIME_PROFILES.map((p) => p.id),
+];
 /**
  * Do we ship knowledge of this runtime?
  *
@@ -364,7 +381,8 @@ exports.KNOWN_RUNTIMES = [...Object.keys(ADAPTERS), ...profiles_1.RUNTIME_PROFIL
  * us, and the Cursor outage was the same mistake from the other side.
  */
 function isKnownRuntime(value) {
-    return Object.prototype.hasOwnProperty.call(ADAPTERS, value) || (0, profiles_1.profileFor)(value) !== undefined;
+    return (Object.prototype.hasOwnProperty.call(ADAPTERS, value) ||
+        (0, profiles_1.profileFor)(value) !== undefined);
 }
 /**
  * Run a headless turn to completion.
@@ -377,6 +395,7 @@ function isKnownRuntime(value) {
 function runHeadless(file, args, opts = {}) {
     return new Promise((resolve) => {
         const child = (0, child_process_1.spawn)(file, args, {
+            windowsHide: true,
             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.

package/dist/relay/autostart.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTOSTART_IMPLEMENTATIONS = exports.LingerUnavailable = exports.SYSTEMD_UNIT_NAME = exports.SERVICE_LABEL = void 0;
+exports.AUTOSTART_IMPLEMENTATIONS = exports.WINDOWS_RELAY_LAUNCHER = exports.LingerUnavailable = exports.SYSTEMD_UNIT_NAME = exports.SERVICE_LABEL = void 0;
 exports.autostartForPlatform = autostartForPlatform;
 exports.relayCommand = relayCommand;
 // Making the relay come back by itself, on all three platforms.
@@ -101,9 +101,17 @@ WantedBy=default.target
         fs.mkdirSync(path.dirname(target), { recursive: true });
         fs.writeFileSync(target, systemd.unit(cmd), { mode: 0o644 });
         await execFileAsync("systemctl", ["--user", "daemon-reload"]);
-        await execFileAsync("systemctl", ["--user", "enable", "--now", exports.SYSTEMD_UNIT_NAME]);
+        await execFileAsync("systemctl", [
+            "--user",
+            "enable",
+            "--now",
+            exports.SYSTEMD_UNIT_NAME,
+        ]);
         try {
-            await execFileAsync("loginctl", ["enable-linger", os.userInfo().username]);
+            await execFileAsync("loginctl", [
+                "enable-linger",
+                os.userInfo().username,
+            ]);
         }
         catch {
             // Not fatal and not silent: the caller prints the degraded promise rather
@@ -112,7 +120,12 @@ WantedBy=default.target
         }
     },
     async uninstall() {
-        await execFileAsync("systemctl", ["--user", "disable", "--now", exports.SYSTEMD_UNIT_NAME]).catch(() => undefined);
+        await execFileAsync("systemctl", [
+            "--user",
+            "disable",
+            "--now",
+            exports.SYSTEMD_UNIT_NAME,
+        ]).catch(() => undefined);
         fs.rmSync(systemd.unitPath(), { force: true });
     },
 };
@@ -175,12 +188,18 @@ const launchd = {
         const domain = `gui/${os.userInfo().uid}`;
         // Replacing an agent means removing the old one first; bootout on a label
         // that was never loaded exits non-zero, which is not a failure here.
-        await execFileAsync("launchctl", ["bootout", `${domain}/${exports.SERVICE_LABEL}`]).catch(() => undefined);
+        await execFileAsync("launchctl", [
+            "bootout",
+            `${domain}/${exports.SERVICE_LABEL}`,
+        ]).catch(() => undefined);
         await execFileAsync("launchctl", ["bootstrap", domain, target]);
     },
     async uninstall() {
         const domain = `gui/${os.userInfo().uid}`;
-        await execFileAsync("launchctl", ["bootout", `${domain}/${exports.SERVICE_LABEL}`]).catch(() => undefined);
+        await execFileAsync("launchctl", [
+            "bootout",
+            `${domain}/${exports.SERVICE_LABEL}`,
+        ]).catch(() => undefined);
         fs.rmSync(launchd.unitPath(), { force: true });
     },
 };
@@ -246,8 +265,8 @@ const scheduledTask = {
   </Settings>
   <Actions Context="Author">
     <Exec>
-      <Command>${escapeXml(cmd.node)}</Command>
-      <Arguments>"${escapeXml(cmd.entry)}" relay start --foreground</Arguments>
+      <Command>${escapeXml(path.win32.join(process.env.SystemRoot || "C:\\Windows", "System32", "wscript.exe"))}</Command>
+      <Arguments>//B //NoLogo ${escapeXml(`"${windowsLauncherPath()}" "${cmd.node}" "${cmd.entry}"`)} relay start --foreground</Arguments>
     </Exec>
   </Actions>
 </Task>
@@ -258,17 +277,47 @@ const scheduledTask = {
     async install(cmd) {
         const target = scheduledTask.unitPath();
         fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(windowsLauncherPath(), exports.WINDOWS_RELAY_LAUNCHER, "utf8");
         // UTF-16LE with a BOM, because that is what the XML declaration above claims
         // and what schtasks refuses the file without.
-        fs.writeFileSync(target, "\ufeff" + scheduledTask.unit(cmd), { encoding: "utf16le" });
-        await execFileAsync("schtasks", ["/create", "/tn", exports.SERVICE_LABEL, "/xml", target, "/f"]);
-        await execFileAsync("schtasks", ["/run", "/tn", exports.SERVICE_LABEL]);
+        fs.writeFileSync(target, "\ufeff" + scheduledTask.unit(cmd), {
+            encoding: "utf16le",
+        });
+        await execFileAsync("schtasks", ["/create", "/tn", exports.SERVICE_LABEL, "/xml", target, "/f"], { windowsHide: true });
+        await execFileAsync("schtasks", ["/run", "/tn", exports.SERVICE_LABEL], {
+            windowsHide: true,
+        });
     },
     async uninstall() {
-        await execFileAsync("schtasks", ["/delete", "/tn", exports.SERVICE_LABEL, "/f"]).catch(() => undefined);
+        // Deleting a task does not stop its running child. End the supervised
+        // process first so `relay stop` cannot leave an invisible orphan behind.
+        await execFileAsync("schtasks", ["/end", "/tn", exports.SERVICE_LABEL], {
+            windowsHide: true,
+        }).catch(() => undefined);
+        await execFileAsync("schtasks", ["/delete", "/tn", exports.SERVICE_LABEL, "/f"], {
+            windowsHide: true,
+        }).catch(() => undefined);
         fs.rmSync(scheduledTask.unitPath(), { force: true });
+        fs.rmSync(windowsLauncherPath(), { force: true });
     },
 };
+/** WSH is a GUI executable, so starting it never allocates a visible console.
+ * Run's window style 0 hides the child too. Waiting and forwarding its exit
+ * code keeps Task Scheduler's restart supervision attached to the actual relay.
+ * This is Windows Script Host JScript, not Node; no cmd.exe or shell is involved.
+ */
+exports.WINDOWS_RELAY_LAUNCHER = `var shell = new ActiveXObject("WScript.Shell");
+var command = [];
+for (var index = 0; index < WScript.Arguments.length; index++) {
+  var argument = WScript.Arguments(index);
+  if (/["\\r\\n]/.test(argument)) throw new Error("Invalid relay startup argument");
+  command.push('"' + argument + '"');
+}
+WScript.Quit(shell.Run(command.join(" "), 0, true));
+`;
+function windowsLauncherPath() {
+    return path.join(configHome(), "relay-launcher.js");
+}
 /** `DOMAIN\user`, which is what a task's `UserId` wants. `USERDOMAIN` is absent
  * on a machine that was never joined to a domain; the bare username is correct
  * there, and inventing a domain would register a task for a principal that does
@@ -327,4 +376,8 @@ function relayCommand(physicalPath = (value) => fs.realpathSync.native(value)) {
 }
 /** Exported for tests, which need to reach a platform other than the one they
  * run on. Production code goes through {@link autostartForPlatform}. */
-exports.AUTOSTART_IMPLEMENTATIONS = { systemd, launchd, scheduledTask };
+exports.AUTOSTART_IMPLEMENTATIONS = {
+    systemd,
+    launchd,
+    scheduledTask,
+};

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

@@ -55,6 +55,7 @@ function runCodexTurn(req, deps) {
         // installed and working.
         const plan = (0, runtime_binary_1.spawnPlanFor)(req.binaryPath, process.platform);
         const child = spawn(plan.file, [...plan.prefixArgs, "app-server"], {
+            windowsHide: true,
             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
@@ -84,7 +85,11 @@ function runCodexTurn(req, deps) {
             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);
+        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);
@@ -133,7 +138,11 @@ function runCodexTurn(req, deps) {
             stderrTail = `${stderrTail}${text}`.slice(-2_000);
         });
         child.on("error", (err) => {
-            finish({ kind: "failed", transportUnusable: true, reason: `could not start codex app-server: ${err.message}` });
+            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
@@ -148,10 +157,18 @@ function runCodexTurn(req, deps) {
         });
         void (async () => {
             const initialized = await request("initialize", {
-                clientInfo: { name: "baychat-relay", title: "BayChat relay", version: CLIENT_VERSION },
+                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}` });
+                finish({
+                    kind: "failed",
+                    transportUnusable: true,
+                    reason: `codex app-server refused the handshake: ${initialized.error.message}`,
+                });
                 return;
             }
             notify("initialized", {});
@@ -185,19 +202,31 @@ function runCodexTurn(req, deps) {
                 // 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}` });
+                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);
+            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}` });
+                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.

package/dist/relay/codex-queue.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queueToThread = queueToThread;
+exports.verifyCodexQueue = verifyCodexQueue;
 const child_process_1 = require("child_process");
 const runtime_binary_1 = require("../runtime-binary");
 const spawn_env_1 = require("./spawn-env");
@@ -40,8 +41,16 @@ function queueToThread(input) {
     // 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], {
+        runner(plan.file, [
+            ...plan.prefixArgs,
+            "queue",
+            "--thread",
+            input.threadId,
+            "--message",
+            input.message,
+        ], {
             cwd: input.cwd,
+            windowsHide: true,
             env: (0, spawn_env_1.headlessSpawnEnv)(),
             timeout: input.timeoutMs ?? QUEUE_TIMEOUT_MS,
             maxBuffer: 1024 * 1024,
@@ -57,12 +66,41 @@ function queueToThread(input) {
             // 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)}` });
+                return resolve({
+                    kind: "unsupported",
+                    reason: `this codex build has no \`queue\` subcommand: ${firstLine(out)}`,
+                });
             }
-            resolve({ kind: "failed", reason: firstLine(out) || err.message });
+            resolve({
+                kind: "failed",
+                reason: firstLine(out) || err.message,
+            });
+        });
+    });
+}
+/** Verify native queue support without submitting a message or changing a task. */
+function verifyCodexQueue(binaryPath) {
+    const plan = (0, runtime_binary_1.spawnPlanFor)(binaryPath, process.platform);
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(plan.file, [...plan.prefixArgs, "queue", "--help"], {
+            env: (0, spawn_env_1.headlessSpawnEnv)(),
+            windowsHide: true,
+            timeout: 5_000,
+            maxBuffer: 64 * 1024,
+        }, (error, stdout) => {
+            if (error ||
+                !stdout.includes("--thread") ||
+                !stdout.includes("--message")) {
+                reject(new Error("This Codex binary cannot receive native queued messages. Update Codex, then join again."));
+            }
+            else
+                resolve();
         });
     });
 }
 function firstLine(text) {
-    return text.split("\n").map((l) => l.trim()).filter(Boolean)[0] ?? "";
+    return (text
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)[0] ?? "");
 }

package/dist/relay/commands.js

@@ -45,6 +45,7 @@ exports.cmdRelayAttach = cmdRelayAttach;
 exports.resolveRuntimeBin = resolveRuntimeBin;
 exports.decideRuntimeBin = decideRuntimeBin;
 const message_format_1 = require("./message-format");
+const codex_queue_1 = require("./codex-queue");
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
@@ -325,7 +326,9 @@ function resumeLabel(s) {
     if (!s.resumeId) {
         return "resume: none — a wake while detached is reported DELIVERY PENDING, not delivered";
     }
-    const provenance = s.resumeEvidence ?? s.resumeSource ?? "origin not recorded (registered before provenance existed)";
+    const provenance = s.resumeEvidence ??
+        s.resumeSource ??
+        "origin not recorded (registered before provenance existed)";
     return `resume: ${s.resumeId} — ${provenance}`;
 }
 /**
@@ -340,7 +343,9 @@ function transportLabel(status) {
     if (!status.transport)
         return "unknown (relay predates transport reporting)";
     const detail = status.transportDetail ? ` (${status.transportDetail})` : "";
-    return status.transport === "websocket" ? `websocket${detail}` : `long-poll${detail}`;
+    return status.transport === "websocket"
+        ? `websocket${detail}`
+        : `long-poll${detail}`;
 }
 async function cmdRelayStop() {
     // Disarm the init system FIRST. Stopping the process without it means the
@@ -351,15 +356,24 @@ async function cmdRelayStop() {
     if (autostart && fs.existsSync(autostart.unitPath())) {
         try {
             await autostart.uninstall();
-            console.log(`Relay stopped and disabled at boot (${autostart.name}).`);
-            return 0;
         }
-        catch {
-            // Fall through to the socket path — the unit may not be the thing running.
+        catch (error) {
+            console.log(`Could not disable relay startup: ${error instanceof Error ? error.message : String(error)}`);
+            return 1;
         }
     }
     try {
-        await request(await connectOrFail(), { type: "stop" });
+        if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
+            // A windowless supervisor may stop without killing its child. Ask the
+            // relay itself to shut down, and wait so the next start cannot reuse it.
+            await request(await connectOrFail(), { type: "stop" });
+            const deadline = Date.now() + 5_000;
+            while (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
+                if (Date.now() >= deadline)
+                    throw new Error("Relay did not stop within five seconds.");
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+        }
         console.log("Relay stopped.");
         return 0;
     }
@@ -542,6 +556,8 @@ function sessionState(s, lastWakeFailure) {
     // outcome outranks a precondition.
     if (lastWakeFailure)
         return `detached — LAST WAKE FAILED, not reachable: ${lastWakeFailure}`;
+    if (s.delivery === "queue")
+        return "native delivery registered (no waiting terminal needed)";
     // INTERRUPTED, NOT GONE — and this line used to read "headless resume ready",
     // which sounds fine and is now actively false.
     //
@@ -567,7 +583,9 @@ function sessionState(s, lastWakeFailure) {
     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)";
+    return s.resumeId
+        ? "detached (headless resume ready)"
+        : "detached (no resume id)";
 }
 /**
  * One `relay status` session line.
@@ -627,9 +645,20 @@ async function cmdRelayAttach(opts) {
         console.log("  For wakes when nothing is listening, put the key in the relay service once; `relay status` says how.");
     }
     const resume = await resolveAttachResumeId(runtime, opts.resumeId, opts.discovery);
+    if (opts.delivery === "queue") {
+        if (runtime !== "codex" || !resume.ok || !runtimeBin.bin) {
+            console.log("Native delivery needs a verified Codex session id and a working Codex binary. Nothing was registered.");
+            return 1;
+        }
+        await (0, codex_queue_1.verifyCodexQueue)(runtimeBin.bin);
+    }
     const sockPath = (0, socket_1.socketPath)();
     const probe = await (0, socket_1.probeSocketDetailed)(sockPath);
     if (shouldFallBackToMailbox(probe)) {
+        if (opts.delivery === "queue") {
+            console.log("Native delivery could not reach the local relay. Allow the BayChat local connection, then join again.");
+            return 1;
+        }
         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({
@@ -671,6 +700,19 @@ async function cmdRelayAttach(opts) {
         };
         sock.on("data", (0, socket_1.createFrameReader)((frame) => {
             if (frame.type === "attached") {
+                if (opts.delivery === "queue") {
+                    if (timer)
+                        clearTimeout(timer);
+                    sock.end();
+                    if (frame.delivery !== "queue") {
+                        console.log("This relay cannot confirm native delivery. Update and restart the BayChat relay, then join again.");
+                        settle(1);
+                        return;
+                    }
+                    console.log(`Connected as "${frame.session}". Messages go to this Codex session automatically; no re-arming is needed.`);
+                    settle(0);
+                    return;
+                }
                 console.log(`Attached as "${frame.session}". Waiting for messages…`);
                 return;
             }
@@ -708,6 +750,7 @@ async function cmdRelayAttach(opts) {
             type: "attach",
             session: opts.session,
             runtime,
+            delivery: opts.delivery,
             resumeId: resume.ok ? resume.resumeId : undefined,
             resumeSource: resume.ok ? resume.source : undefined,
             resumeEvidence: resume.ok ? resume.evidence : undefined,
@@ -835,7 +878,12 @@ async function resolveAttachResumeId(runtime, explicit, discovery) {
         // Not validated: `--resume-id` is the escape hatch, and a runtime whose ids
         // are not uuids must still be able to use it.
         console.log(`Resume id: ${given} (passed with --resume-id)`);
-        return { ok: true, resumeId: given, source: "flag", evidence: "passed with --resume-id" };
+        return {
+            ok: true,
+            resumeId: given,
+            source: "flag",
+            evidence: "passed with --resume-id",
+        };
     }
     const found = await (0, resume_1.resumeIdFromSessionEnv)(runtime, discovery);
     if (found.ok) {

package/dist/relay/daemon.js

@@ -177,7 +177,9 @@ class RelayDaemon {
         this.spawnHeadless = opts.spawnHeadless ?? adapters_1.runHeadless;
         this.isAlive = opts.isAlive ?? parent_watch_1.processIsAlive;
         this.reattachGraceMs = opts.reattachGraceMs ?? 4000;
-        this.resolveBinary = opts.resolveBinary ?? ((name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, (0, runtime_binary_1.currentBinaryEnv)()));
+        this.resolveBinary =
+            opts.resolveBinary ??
+                ((name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, (0, runtime_binary_1.currentBinaryEnv)()));
         this.runTurn = opts.runTurn;
         this.queue = new queue_1.SessionQueue((session, batch) => this.deliver(session, batch), (session, err) => {
             this.lastError = `delivery failed for ${session}: ${errText(err)}`;
@@ -306,7 +308,11 @@ class RelayDaemon {
                 // has already died would otherwise clear the hold AND record `woken` —
                 // destroying the only copy of the messages and filing them as
                 // delivered, which is worse than never having held them.
-                await (0, socket_1.writeFrameAck)(sock, { type: "wake", conversationId: room.conversationId, messages: room.messages });
+                await (0, socket_1.writeFrameAck)(sock, {
+                    type: "wake",
+                    conversationId: room.conversationId,
+                    messages: room.messages,
+                });
             }
             catch (err) {
                 // KEEP IT. This store is the only copy: dropping it because the handoff
@@ -408,7 +414,11 @@ class RelayDaemon {
                 // reported as delivered. A write that does not complete is not a
                 // delivery, and the rungs below exist for exactly this case.
                 try {
-                    await (0, socket_1.writeFrameAck)(sock, { type: "wake", conversationId: batch[0].conversationId, messages: batch });
+                    await (0, socket_1.writeFrameAck)(sock, {
+                        type: "wake",
+                        conversationId: batch[0].conversationId,
+                        messages: batch,
+                    });
                     this.record({ kind: "woken", via: "attach", session }, session, batch);
                     return;
                 }
@@ -462,9 +472,18 @@ class RelayDaemon {
                     message: (0, adapters_1.buildWakePrompt)(session, batch[0].conversationId, batch, undefined),
                 });
                 if (outcome.kind === "queued") {
+                    this.held.acknowledge(session, batch[0].conversationId, batch.map((message) => message.id));
                     this.record({ kind: "woken", via: "queue", session }, session, batch);
                     return;
                 }
+                if (target.delivery === "queue") {
+                    this.record({
+                        kind: "pending",
+                        session,
+                        reason: `Native Codex delivery failed: ${outcome.reason}`,
+                    }, session, batch);
+                    return;
+                }
                 // EVERY non-success falls through, including `failed`.
                 //
                 // The queue is an OPTIMISATION, not a gate: it reaches the live session so
@@ -477,6 +496,14 @@ class RelayDaemon {
                 this.log(`queue did not deliver for ${session} (${outcome.reason}) — falling through to headless`);
             }
         }
+        if (target.delivery === "queue") {
+            this.record({
+                kind: "pending",
+                session,
+                reason: "Native Codex delivery is unavailable; join again from the existing session.",
+            }, session, batch);
+            return;
+        }
         // A target with no resume id is the unbounded failure this whole path
         // exists to close: without one, `canResume` says no and the message waits
         // for a human. Ask the runtime's own on-disk state who this session is
@@ -533,11 +560,17 @@ class RelayDaemon {
         // namespaced pid that reads alive forever (spec §13) — so applying this to
         // fifo sessions would permanently shadow the one rung that can still reach
         // them, which is the 2026-08-31 00:04 regression in a new costume.
-        if (!mailbox && target.ownerPid !== undefined && this.isAlive(target.ownerPid)) {
+        if (!mailbox &&
+            target.ownerPid !== undefined &&
+            this.isAlive(target.ownerPid)) {
             const rearmed = await this.waitForReattach(session, this.reattachGraceMs);
             if (rearmed) {
                 try {
-                    await (0, socket_1.writeFrameAck)(rearmed, { type: "wake", conversationId: batch[0].conversationId, messages: batch });
+                    await (0, socket_1.writeFrameAck)(rearmed, {
+                        type: "wake",
+                        conversationId: batch[0].conversationId,
+                        messages: batch,
+                    });
                     this.record({ kind: "woken", via: "attach", session }, session, batch);
                     return;
                 }
@@ -572,7 +605,9 @@ class RelayDaemon {
         if (!check.ok) {
             // The honest outcome: it reached this box, and nothing answered it.
             const why = this.discoveryReasons.get(session)?.reason;
-            const reason = why ? `${check.reason ?? "cannot resume"}; discovery: ${why}` : (check.reason ?? "cannot resume");
+            const reason = why
+                ? `${check.reason ?? "cannot resume"}; discovery: ${why}`
+                : (check.reason ?? "cannot resume");
             this.record({ kind: "pending", session, reason }, session, batch);
             return;
         }
@@ -617,7 +652,11 @@ class RelayDaemon {
         if (!path.isAbsolute(file)) {
             const binary = this.binaryFor(file);
             if (!binary.ok) {
-                this.record({ kind: "pending", session, reason: (0, runtime_binary_1.summarizeResolutionFailure)(binary) }, session, batch);
+                this.record({
+                    kind: "pending",
+                    session,
+                    reason: (0, runtime_binary_1.summarizeResolutionFailure)(binary),
+                }, session, batch);
                 return;
             }
             executable = binary.path;
@@ -639,7 +678,11 @@ class RelayDaemon {
         // why. So this is mutual exclusion between headless turns, and observability
         // for attach-vs-headless. Claiming more than that is what the review caught.
         if (this.headlessInFlight.has(session)) {
-            this.record({ kind: "pending", session, reason: "a headless turn is already running for this session — refusing to start a second" }, session, batch);
+            this.record({
+                kind: "pending",
+                session,
+                reason: "a headless turn is already running for this session — refusing to start a second",
+            }, session, batch);
             return;
         }
         this.headlessInFlight.add(session);
@@ -655,7 +698,17 @@ class RelayDaemon {
         // Released here, the lease still stops a SECOND headless turn starting, and
         // the message that would have started it is now recorded pending with a
         // reason a person can read. Silence becomes a visible refusal.
-        void this.runHeadlessTurn({ session, batch, target, adapter, resolved, executable, prompt, args, file })
+        void this.runHeadlessTurn({
+            session,
+            batch,
+            target,
+            adapter,
+            resolved,
+            executable,
+            prompt,
+            args,
+            file,
+        })
             .catch((err) => {
             // Nothing awaits this promise any more, so an escaping rejection would
             // be an unhandled one — which can take the whole daemon down and with it
@@ -663,7 +716,11 @@ class RelayDaemon {
             // the honest record is pending.
             const reason = err instanceof Error ? err.message : String(err);
             this.log(`headless turn for ${session} threw: ${reason}`);
-            this.record({ kind: "pending", session, reason: `headless turn threw: ${reason}` }, session, batch);
+            this.record({
+                kind: "pending",
+                session,
+                reason: `headless turn threw: ${reason}`,
+            }, session, batch);
         })
             .finally(() => {
             this.headlessInFlight.delete(session);
@@ -677,7 +734,7 @@ class RelayDaemon {
      * or pending with a reason — happens whenever the turn actually ends.
      */
     async runHeadlessTurn(ctx) {
-        const { session, batch, target, adapter, resolved, executable, prompt, args, file } = ctx;
+        const { session, batch, target, adapter, resolved, executable, prompt, args, file, } = ctx;
         try {
             // A runtime with a richer transport than "spawn a command" gets to use it.
             // Only a transport that could not be used AT ALL falls through to the spawn:
@@ -688,7 +745,11 @@ class RelayDaemon {
                 ? (input) => this.runTurn({ runtime: target.runtime, ...input })
                 : adapter.runTurn?.bind(adapter);
             if (richTransport) {
-                const outcome = await richTransport({ binaryPath: executable, target: resolved, prompt });
+                const outcome = await richTransport({
+                    binaryPath: executable,
+                    target: resolved,
+                    prompt,
+                });
                 if (outcome.kind === "completed") {
                     this.record({ kind: "woken", via: "headless", session, exitCode: 0 }, session, batch);
                     return;
@@ -717,7 +778,11 @@ class RelayDaemon {
                 this.binaries.delete(file);
                 // A non-zero headless turn did not necessarily reply. Recording it as
                 // delivered would claim an answer we cannot evidence.
-                this.record({ kind: "pending", session, reason: `headless ${target.runtime} exited ${exitCode}: ${stderr.slice(0, 200)}` }, session, batch);
+                this.record({
+                    kind: "pending",
+                    session,
+                    reason: `headless ${target.runtime} exited ${exitCode}: ${stderr.slice(0, 200)}`,
+                }, session, batch);
                 return;
             }
             this.record({ kind: "woken", via: "headless", session, exitCode }, session, batch);
@@ -763,7 +828,10 @@ class RelayDaemon {
             return target;
         const result = await (0, adapters_1.adapterFor)(target.runtime).discoverResume(target, this.discovery);
         if (!result.ok) {
-            this.discoveryReasons.set(target.name, { at: Date.now(), reason: result.reason });
+            this.discoveryReasons.set(target.name, {
+                at: Date.now(),
+                reason: result.reason,
+            });
             this.log(`no resume id for ${target.name}: ${result.reason}`);
             return target;
         }
@@ -814,10 +882,19 @@ class RelayDaemon {
         let session;
         const read = (0, socket_1.createFrameReader)((frame) => {
             if (frame.type === "attach") {
+                if (frame.delivery === "queue" &&
+                    (frame.runtime !== "codex" || !frame.resumeId || !frame.runtimeBin)) {
+                    (0, socket_1.writeFrame)(sock, {
+                        type: "error",
+                        message: "Native registration requires a Codex session id and binary.",
+                    });
+                    return;
+                }
                 session = frame.session;
                 this.registry.upsert({
                     name: frame.session,
                     runtime: frame.runtime,
+                    delivery: frame.delivery,
                     resumeId: frame.resumeId,
                     resumeSource: frame.resumeSource,
                     resumeEvidence: frame.resumeEvidence,
@@ -850,6 +927,21 @@ class RelayDaemon {
                     this.log(`replacing attach for ${frame.session}: dropping the previous one`);
                     previous.destroy();
                 }
+                if (frame.delivery === "queue") {
+                    this.attached.delete(frame.session);
+                    this.registry.setAttached(frame.session, false);
+                    (0, socket_1.writeFrame)(sock, {
+                        type: "attached",
+                        session: frame.session,
+                        delivery: "queue",
+                    });
+                    this.log(`registered native delivery: ${frame.session} (${frame.runtime})`);
+                    for (const room of this.held.roomsFor(frame.session)) {
+                        for (const message of room.messages)
+                            this.queue.push(frame.session, message);
+                    }
+                    return;
+                }
                 this.attached.set(frame.session, sock);
                 this.registry.setAttached(frame.session, true);
                 (0, socket_1.writeFrame)(sock, { type: "attached", session: frame.session });
@@ -867,7 +959,10 @@ class RelayDaemon {
                 setTimeout(() => void this.stop(), 50);
                 return;
             }
-        }, (bad) => (0, socket_1.writeFrame)(sock, { type: "error", message: `bad frame: ${bad.slice(0, 80)}` }));
+        }, (bad) => (0, socket_1.writeFrame)(sock, {
+            type: "error",
+            message: `bad frame: ${bad.slice(0, 80)}`,
+        }));
         sock.on("data", read);
         const drop = () => {
             if (session && this.attached.get(session) === sock) {
@@ -883,7 +978,11 @@ class RelayDaemon {
         const sessions = this.registry.all().map((t) => ({
             ...t,
             attached: this.attached.has(t.name) || this.mailboxes.has(t.name),
-            transport: this.attached.has(t.name) ? "socket" : this.mailboxes.has(t.name) ? "fifo" : undefined,
+            transport: this.attached.has(t.name)
+                ? "socket"
+                : this.mailboxes.has(t.name)
+                    ? "fifo"
+                    : undefined,
         }));
         return {
             running: true,
@@ -908,7 +1007,7 @@ class RelayDaemon {
         await this.queue.idle();
         for (const w of this.mailboxWatchers)
             w.stop();
-        await new Promise((resolve) => (this.server ? this.server.close(() => resolve()) : resolve()));
+        await new Promise((resolve) => this.server ? this.server.close(() => resolve()) : resolve());
         (0, socket_1.unlinkStaleSocket)((0, socket_1.socketPath)());
         try {
             fs.unlinkSync((0, socket_1.pidFilePath)());

package/dist/relay/held.js

@@ -70,6 +70,18 @@ function heldPath() {
  */
 class HeldStore {
     filePath;
+    /** Remove only messages the native queue acknowledged, preserving other rooms and pending messages. */
+    acknowledge(session, conversationId, messageIds) {
+        const room = this.rooms.get(session)?.get(conversationId);
+        if (!room)
+            return;
+        const accepted = new Set(messageIds);
+        room.messages = room.messages.filter((message) => !accepted.has(message.id));
+        if (room.messages.length === 0)
+            this.clearRoom(session, conversationId);
+        else
+            this.save();
+    }
     /** session → conversationId → room. */
     rooms = new Map();
     constructor(filePath = heldPath()) {
@@ -94,11 +106,15 @@ class HeldStore {
             const rooms = new Map();
             for (const [conversationId, value] of Object.entries(bySession)) {
                 const room = value;
-                if (!room || !Array.isArray(room.messages) || room.messages.length === 0)
+                if (!room ||
+                    !Array.isArray(room.messages) ||
+                    room.messages.length === 0)
                     continue;
                 rooms.set(conversationId, {
                     conversationId,
-                    heldAt: typeof room.heldAt === "string" ? room.heldAt : new Date().toISOString(),
+                    heldAt: typeof room.heldAt === "string"
+                        ? room.heldAt
+                        : new Date().toISOString(),
                     messages: room.messages,
                 });
             }
@@ -122,7 +138,9 @@ class HeldStore {
                 fs.rmSync(this.filePath, { force: true });
                 return;
             }
-            fs.writeFileSync(this.filePath, JSON.stringify(out, null, 2), { mode: 0o600 });
+            fs.writeFileSync(this.filePath, JSON.stringify(out, null, 2), {
+                mode: 0o600,
+            });
         }
         catch {
             // Losing durability is not losing the hold: the in-memory copy still
@@ -138,7 +156,11 @@ class HeldStore {
      */
     add(session, conversationId, messages) {
         const rooms = this.rooms.get(session) ?? new Map();
-        const room = rooms.get(conversationId) ?? { conversationId, heldAt: new Date().toISOString(), messages: [] };
+        const room = rooms.get(conversationId) ?? {
+            conversationId,
+            heldAt: new Date().toISOString(),
+            messages: [],
+        };
         for (const m of messages) {
             if (!room.messages.some((held) => held.id === m.id))
                 room.messages.push(m);
@@ -175,7 +197,12 @@ class HeldStore {
         const out = [];
         for (const [session, rooms] of this.rooms) {
             for (const room of rooms.values()) {
-                out.push({ session, conversationId: room.conversationId, count: room.messages.length, heldAt: room.heldAt });
+                out.push({
+                    session,
+                    conversationId: room.conversationId,
+                    count: room.messages.length,
+                    heldAt: room.heldAt,
+                });
             }
         }
         return out.sort((a, b) => Date.parse(a.heldAt) - Date.parse(b.heldAt));

package/dist/runtime-binary.js

@@ -68,11 +68,20 @@ function resolveRuntimeBinary(name, env) {
     for (const candidate of candidates) {
         const probed = env.probe(candidate.path);
         if (probed.ok) {
-            return { ok: true, path: candidate.path, version: probed.version, source: candidate.source };
+            return {
+                ok: true,
+                path: candidate.path,
+                version: probed.version,
+                source: candidate.source,
+            };
         }
         rejected.push({ path: candidate.path, reason: probed.detail });
     }
-    return { ok: false, reason: `no working ${name} binary on this machine`, rejected };
+    return {
+        ok: false,
+        reason: `no working ${name} binary on this machine`,
+        rejected,
+    };
 }
 /** Render a resolution for a human — one line on success, a full account on failure. */
 function describeResolution(name, resolution) {
@@ -101,7 +110,12 @@ function resolveOverride(override, env) {
     }
     const probed = env.probe(override);
     if (probed.ok)
-        return { ok: true, path: override, version: probed.version, source: "override" };
+        return {
+            ok: true,
+            path: override,
+            version: probed.version,
+            source: "override",
+        };
     return {
         ok: false,
         reason: `configured override ${override} does not run`,
@@ -122,7 +136,9 @@ function pathCandidates(name, env) {
     for (const entry of env.pathEntries) {
         if (entry.trim() === "")
             continue;
-        const source = isForeignMount(entry, env.platform) ? "foreign-path" : "path";
+        const source = isForeignMount(entry, env.platform)
+            ? "foreign-path"
+            : "path";
         for (const fileName of executableNames(name, env.platform)) {
             const candidate = joinPath(entry, fileName, env.platform);
             if (seen.has(candidate))
@@ -166,7 +182,9 @@ function executableNames(name, platform) {
  */
 function joinPath(dir, file, platform) {
     const separator = platform === "win32" ? "\\" : "/";
-    const trimmed = dir.endsWith(separator) ? dir.slice(0, -separator.length) : dir;
+    const trimmed = dir.endsWith(separator)
+        ? dir.slice(0, -separator.length)
+        : dir;
     return `${trimmed}${separator}${file}`;
 }
 /**
@@ -209,7 +227,8 @@ function summarizeProbe(outcome) {
     if (outcome.status !== 0) {
         // Prefer stderr: a failing CLI puts its diagnosis there, and it is what
         // names the actual fault (e.g. the missing optional dependency).
-        const said = firstMeaningfulLine(outcome.stderr) || firstMeaningfulLine(outcome.stdout);
+        const said = firstMeaningfulLine(outcome.stderr) ||
+            firstMeaningfulLine(outcome.stdout);
         const exited = `exits ${outcome.status ?? "on a signal"}`;
         return { ok: false, detail: said ? `${exited}: ${said}` : exited };
     }
@@ -270,6 +289,7 @@ function currentBinaryEnv(override, env = process.env, execPath = process.execPa
         probe(candidate) {
             const plan = spawnPlanFor(candidate, process.platform);
             const run = (0, child_process_1.spawnSync)(plan.file, [...plan.prefixArgs, "--version"], {
+                windowsHide: true,
                 timeout: PROBE_TIMEOUT_MS,
                 encoding: "utf8",
                 shell: false,

package/dist/runtimes.js

@@ -28,7 +28,15 @@ exports.renderCommandFor = renderCommandFor;
 // The rooms guidance is shared with `baychat help groups`, so the words a person
 // reads in their terminal and the words their agent was given are the same words.
 const help_topics_1 = require("./help-topics");
-exports.RUNTIMES = ["claude", "codex", "cursor", "desktop", "pi", "hermes", "generic"];
+exports.RUNTIMES = [
+    "claude",
+    "codex",
+    "cursor",
+    "desktop",
+    "pi",
+    "hermes",
+    "generic",
+];
 const GENERIC_RESUME_NOTE = `The relay can only wake this session while \`attach\` is running. Re-arm it after
 every wake; a message that arrives while nothing is listening is recorded
 DELIVERY PENDING and waits for a human.`;
@@ -55,7 +63,9 @@ function attachFor(spec) {
             reachability: reachabilityFor(attachLine, GENERIC_RESUME_NOTE, "background-every-wake"),
         };
     }
-    const resumeFlag = spec.relay.sessionIdExpr ? ` --resume-id "${spec.relay.sessionIdExpr}"` : "";
+    const resumeFlag = spec.relay.sessionIdExpr
+        ? ` --resume-id "${spec.relay.sessionIdExpr}"`
+        : "";
     const attachLine = `baychat relay attach --session "<name>" --runtime ${spec.relay.runtime}${resumeFlag}`;
     return {
         attachLine,
@@ -76,38 +86,25 @@ function attachFor(spec) {
  */
 function reachabilityFor(attachLine, resumeNote, reArm) {
     if (reArm === "arm-once") {
-        // BOUNDED. `cmdRelayAttach` only installs a timer when `--timeout` is given,
-        // and the mailbox path blocks in `readFile(fifo)` with no deadline at all —
-        // so an unbounded "arm once" command hangs the agent's turn until a message
-        // happens to arrive. Registration completes in milliseconds; the wait is not
-        // what this rung is for.
-        const bounded = `${attachLine} --timeout 30`;
-        return `## Staying reachable — arm once
-
-If \`baychat relay\` is running on this machine (\`baychat connect\` starts it), run
-this ONCE, in the FOREGROUND, as soon as you have joined:
-
-\`\`\`
-${bounded}
-\`\`\`
+        return `## Staying reachable — automatic delivery
 
-This is how the relay learns which runtime session you are. \`--timeout 30\` is
-part of the command, not a suggestion: registration is the point here, and the
-wait is not. Without it the command blocks until a message happens to arrive,
-which hangs your turn for no benefit.
-
-**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.
+\`baychat join\` registers this verified Codex task with the relay, confirms native
+delivery, and returns immediately. Run that short command in the FOREGROUND.
+**Do NOT put it in the background.** No waiting terminal or polling tool is needed.
 
 **You do not need to re-arm it.** ${resumeNote}
 
-It prints \`No new messages before timeout.\` and exits — that is success, not a
-failure. Arm once, then get on with your work.
+Do not run a separate \`relay attach\` after joining. If registration fails, show
+the actual error and fix it; a join alone does not prove incoming delivery works.
+Recovery is to rerun the same join with the user's confirmed name and room.
+
+Incoming BayChat messages appear in this task as \`@Sender\` text. Answer in the
+confirmed BayChat conversation when \`shouldRespond\` authorizes you, and echo
+your chat reply here so the user can follow the same conversation. Do not mirror
+tool output, credentials, private reasoning or unrelated coding conversation.
 
-If you are ever unsure whether the relay knows you, run \`baychat relay status\`:
-you are reachable when your session is listed with a resume id, whether or not
-anything is attached.`;
+A native queue receipt means accepted by Codex, not read or answered. Codex may
+queue messages behind an active turn; never describe that as an instant reply.`;
     }
     if (reArm === "supervised-loop") {
         // WHO runs attach again is the whole fix — attach itself is unchanged.
@@ -258,7 +255,7 @@ ${help_topics_1.ROOMS_TOPIC}
    room context, starts the relay if needed, and connects incoming messages.
    ${ctx.runtime === "claude"
         ? "Run it with the **Monitor** tool, **persistent: true**. It stays in the foreground and re-arms itself after each wake. Do not start a second attach loop while this command is running."
-        : "Run it in the **foreground**. Codex uses a bounded 30-second wait; never use nohup, setsid or shell backgrounding."}
+        : "Run it in the **foreground**. Codex returns after native delivery registration; never use nohup, setsid or shell backgrounding."}
 2. Use the **server-confirmed name** as \`session\` on every later BayChat tool
    call, including \`list_agents\` and \`contact_agent\`. There is no default.
    Print the confirmed name and room to the user. A join refusal or delivery
@@ -464,7 +461,11 @@ DELIVERY PENDING and waits for a human — re-arm attach after every wake, witho
     desktop: {
         id: "desktop",
         label: "Claude Desktop",
-        mcp: { kind: "file", format: "json", describe: "claude_desktop_config.json" },
+        mcp: {
+            kind: "file",
+            format: "json",
+            describe: "claude_desktop_config.json",
+        },
         // Claude Desktop has no user-authored command mechanism on disk.
         command: null,
         invocation: 'ask it to "join BayChat as <name>"',
@@ -486,7 +487,10 @@ DELIVERY PENDING and waits for a human — re-arm attach after every wake, witho
     hermes: {
         id: "hermes",
         label: "Hermes",
-        mcp: { kind: "manual", describe: "printed `mcp_servers` block for ~/.hermes/config.yaml" },
+        mcp: {
+            kind: "manual",
+            describe: "printed `mcp_servers` block for ~/.hermes/config.yaml",
+        },
         // Hermes is self-hosted: it is WOKEN through the Agent API (its platform
         // adapter long-polls), and it ACTS through our remote MCP endpoint. Two
         // halves, and this entry used to claim the second did not exist — "Hermes
@@ -520,7 +524,12 @@ function runtimeSpec(id) {
 /** The full `CommandContext` a runtime's skill body is rendered from. */
 function commandContextFor(id) {
     const spec = exports.RUNTIME_SPECS[id];
-    return { runtime: id, invocation: spec.invocation, name: "baychat", ...attachFor(spec) };
+    return {
+        runtime: id,
+        invocation: spec.invocation,
+        name: "baychat",
+        ...attachFor(spec),
+    };
 }
 /** Body for a runtime's command file, or null when it has none. */
 function renderCommandFor(id) {

package/dist/session-command.js

@@ -36,10 +36,14 @@ function parseJoinArgs(args) {
         }
     }
     if (positionals.length > 2)
-        throw new Error('Usage: baychat join [name] [group] [--runtime runtime]');
+        throw new Error("Usage: baychat join [name] [group] [--runtime runtime]");
     if (positionals[1] && options.group)
         throw new Error("Choose the group once, as a title or with --group.");
-    return { ...options, session: positionals[0], group: options.group ?? positionals[1] };
+    return {
+        ...options,
+        session: positionals[0],
+        group: options.group ?? positionals[1],
+    };
 }
 /** Join and arm the current terminal in one foreground command.
  * The server owns identity/membership; the relay owns native wake delivery.
@@ -57,10 +61,15 @@ async function cmdJoinSession(args) {
     if (runtime === "hermes") {
         throw new Error("Hermes is a persistent agent. Use baychat connect hermes.");
     }
-    if (joining && runtime !== "codex" && runtime !== "claude" && runtime !== "cursor") {
+    if (joining &&
+        runtime !== "codex" &&
+        runtime !== "claude" &&
+        runtime !== "cursor") {
         throw new Error("Supported coding runtimes: codex, claude, cursor.");
     }
-    let name = joining ? options.session ?? await (0, session_name_1.automaticSessionName)(runtime) : undefined;
+    let name = joining
+        ? (options.session ?? (await (0, session_name_1.automaticSessionName)(runtime)))
+        : undefined;
     const client = new index_js_1.Client({ name: "baychat-session", version: "1" });
     try {
         await client.connect(new streamableHttp_js_1.StreamableHTTPClientTransport(new URL("/api/mcp", device.baseUrl), {
@@ -71,18 +80,21 @@ async function cmdJoinSession(args) {
         }));
         const result = await client.callTool({
             name: joining ? "join_session" : "list_sessions",
-            arguments: joining ? { session: name, ...(options.group ? { group: options.group } : {}) } : {},
+            arguments: joining
+                ? { session: name, ...(options.group ? { group: options.group } : {}) }
+                : {},
         });
         const text = (0, message_format_1.cleanTerminalText)(result.content
-            .filter(item => item.type === "text")
-            .map(item => item.text ?? "")
+            .filter((item) => item.type === "text")
+            .map((item) => item.text ?? "")
             .join("\n"));
         if (result.isError)
             throw new Error(text || "BayChat refused the session request.");
         if (joining) {
             const structured = result.structuredContent;
             const confirmedName = structured && typeof structured === "object" && "session" in structured
-                ? structured.session : undefined;
+                ? structured.session
+                : undefined;
             if (typeof confirmedName !== "string" || !confirmedName.trim()) {
                 throw new Error("The server did not confirm the session identity. Check the API version before retrying.");
             }
@@ -100,7 +112,7 @@ async function cmdJoinSession(args) {
     const startup = await (0, commands_1.ensureRelayInstalled)();
     let status = await (0, commands_1.tryRelayStatus)();
     for (let attempt = 0; !status && attempt < 10; attempt++) {
-        await new Promise(resolve => setTimeout(resolve, 100));
+        await new Promise((resolve) => setTimeout(resolve, 100));
         status = await (0, commands_1.tryRelayStatus)();
     }
     if (!status) {
@@ -111,9 +123,10 @@ async function cmdJoinSession(args) {
     const attach = () => (0, commands_1.cmdRelayAttach)({
         session: name,
         runtime: runtime,
-        // Codex must keep this command in the foreground; a bounded wait returns
-        // control to its tool loop. Other runtimes supervise their own foreground wait.
-        ...(runtime === "codex" ? { timeoutMs: 30_000 } : {}),
+        // Native delivery only needs a confirmed registration, not a waiting tool.
+        ...(runtime === "codex"
+            ? { delivery: "queue", timeoutMs: 5_000 }
+            : {}),
     });
     let code = await attach();
     // Claude's Monitor keeps this foreground process alive. Re-arm immediately

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex) with BayChat and chat in groups",
   "bin": {
     "baychat": "dist/index.js"