baychat 0.19.0 → 0.20.1

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"));
@@ -163,7 +164,7 @@ async function ensureRelayInstalled() {
             return "Relay: auto-start skipped (BAYCHAT_NO_RELAY_AUTOSTART). Run `baychat relay start` to enable wake-ups.";
         }
         if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)()))
-            return "Relay: already running — sessions wake instantly.";
+            return "Relay: running. Join a session to connect incoming messages.";
         const autostart = (0, autostart_1.autostartForPlatform)();
         if (!autostart) {
             return `Relay: no automatic startup on ${process.platform}. Run \`baychat relay start --foreground\` to wake sessions instantly.`;
@@ -176,7 +177,7 @@ async function ensureRelayInstalled() {
                 throw err;
             return `Relay: installed and started, but only at login — ${err.message}.`;
         }
-        return "Relay: installed and started — sessions now wake the moment a message arrives.";
+        return "Relay: startup requested. Join a session to check incoming delivery.";
     }
     catch (err) {
         return `Relay: could not start automatically (${err instanceof Error ? err.message : String(err)}). Run \`baychat relay start\` yourself.`;
@@ -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));