baychat 0.34.0 → 0.34.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.34.0",
+  "version": "0.34.2",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/README.md

@@ -381,9 +381,18 @@ listener, and in whether anything reaches them once the window is closed.
 | Runtime | Who re-arms the listener | Window closed |
 |---|---|---|
 | **Claude Code (native)** | socket stays open; a closed socket needs a replacement Monitor | not reachable until resumed |
-| **Codex** | nobody needs to — its own queue | not reachable |
+| **Codex** | nobody needs to — its own queue | resumed headlessly; its approvals come to your phone (Codex ≥ 0.160) |
 | **Cursor** | **the agent itself**, after every wake | not reachable |
 
+**Codex started from the app is run by the relay** (since 2026-10-23, Codex ≥ 0.160): one
+`codex app-server` turn per message, in its folder's sandbox with no network, and every approval
+Codex asks for — a command, a file change with its diff, network access — comes to your phone
+as a card: "Allow once", "Allow for this session" (confirmed with Face ID), "Deny". Nobody
+answering within 10 minutes is a Deny. Turns woken by someone without command access are read
+only and never ask you. `tmux attach -t bc-<name>` (or `baychat relay log <name> -f`) shows
+what it does. With `BAYCHAT_CODEX_TRANSPORT=exec` on the relay, Codex can't answer in BayChat, so
+launches from the phone are refused and messages to these sessions wait (the room is told why).
+
 Cursor's relay does work — it runs shell commands, so it holds the listener
 like anything else. It is simply the least robust of the three, and the only
 one where remembering to re-arm falls to the agent.
@@ -431,6 +440,7 @@ one where remembering to re-arm falls to the agent.
 | `baychat relay start [--foreground]` | Run the **relay**: one long-poll for this whole machine that wakes local sessions the moment a message arrives. Installs a systemd user unit so it returns after a reboot (see [Relay](#relay)) |
 | `baychat relay status` | Sessions, cursor, and any **delivery pending** — messages that reached this box and that nothing answered (exit 2 if any) |
 | `baychat relay stop` | Stop the relay and disable it at boot |
+| `baychat relay log <session> [-f]` | What a Codex session the relay runs did — commands, file changes, answers, approval cards. `-f` keeps following it (works on Windows too) |
 | `baychat claude [args…]` | Start Claude Code in this terminal with the BayChat channel on (see [No Monitor deadline with the channel](#coding-sessions-one-short-command)). Every argument is passed to Claude Code, `--help` included |
 | `baychat doctor [--json]` | **Run this when something does not work.** Checks every link between this machine and BayChat — credential, relay, and per runtime its MCP registration, skill, executable and live session (and for Claude Code the channel: a plugin that carries it, on Node 22+) — and prints exactly what to type for each thing that is wrong. Exit 0 clear, 1 broken, 2 messages nothing answered. `--json` for pasting into a support thread (see [When something does not work](#when-something-does-not-work)) |
 | `baychat relay attach --session <name> [--runtime claude\|codex\|cursor\|hermes] [--resume-id <id>] [--conversation <id>] [--timeout <sec>]` | Register this session with the relay and block until it is woken (exit 0) or the wait lapses (exit 2) |
@@ -1071,7 +1081,8 @@ Two refusals worth knowing in advance:
 | `BAYCHAT_TOKEN` | Use this agent API token instead of the credentials file (headless/CI) |
 | `BAYCHAT_DEVICE_TOKEN` | Use this `bay_u_*` device token (from `baychat login`) instead of the credentials file (headless/CI) |
 | `BAYCHAT_API_URL` | API origin (default `https://api.baychat.io`) |
-| `BAYCHAT_CONFIG_DIR` | Credentials/cursor directory (default `~/.baychat`) |
+| `BAYCHAT_CONFIG_DIR` | Credentials/cursor directory (default `~/.baychat`). A login made with it set — or against a server other than `https://api.baychat.io` — leaves the computer's agent clients (Claude Code, Claude Desktop, Codex, Cursor) as they are; connect one on purpose with `baychat connect <client>` |
+| `BAYCHAT_REFRESH_CLIENTS=1` | Refresh every connected agent client after such a login anyway |
 
 ## Security
 

package/dist/bays-command.js

@@ -7,6 +7,7 @@ exports.cmdBays = cmdBays;
 const config_1 = require("./config");
 const bays_1 = require("./bays");
 const bay_mcp_1 = require("./bay-mcp");
+const client_scope_1 = require("./client-scope");
 const bay_deleted_1 = require("./bay-deleted");
 const commands_1 = require("./commands");
 const client_paths_1 = require("./client-paths");
@@ -50,6 +51,11 @@ function cmdBays(args) {
     console.log(`✓ ${target.bayName} is now this computer's default Bay.`);
     // The default is the `baychat` entry: every connected client gets the new token there, and
     // the Bay that WAS the default moves to its own `baychat-<bay>` entry.
+    const isolated = (0, client_scope_1.isolatedLoginReason)(next.device.baseUrl);
+    if (isolated) {
+        console.log((0, client_scope_1.isolatedLoginNotice)(isolated));
+        return 0;
+    }
     (0, commands_1.refreshConnectedClients)(next.device.baseUrl, next.device.token);
     (0, commands_1.registerWithClaude)(next.device.baseUrl, next.device.token);
     (0, bay_mcp_1.applyBayEntries)(next.device.baseUrl, bays, next.bays, {

package/dist/channel/feed.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelFeed = exports.BACKOFF_MS = exports.CLOSE_STOPPED = void 0;
+exports.ChannelFeed = exports.MAX_FAILED_RECONNECTS = exports.BACKOFF_MS = exports.CLOSE_STOPPED = void 0;
 /** Close code the server sends when a feed was stopped or replaced on purpose. */
 exports.CLOSE_STOPPED = 4000;
 /** Seconds between reconnect attempts: quick at first, then no more than once a minute. */
 exports.BACKOFF_MS = [1_000, 2_000, 5_000, 10_000, 30_000, 60_000];
 const READY_TIMEOUT_MS = 10_000;
+/**
+ * Consecutive reconnects that fail before the feed gives up and SAYS so (about six minutes of
+ * backoff — longer than a deploy). Before 2026-10-23 it retried forever without a word, and a
+ * feed that never came back looked exactly like a quiet Bay.
+ */
+exports.MAX_FAILED_RECONNECTS = 10;
 const WATCHDOG_MS = 2 * 60_000;
 /** A timer that fires this much later than asked means the computer slept: reconnect at once. */
 const SLEEP_GAP_MS = 60_000;
@@ -131,6 +137,25 @@ class ChannelFeed {
         const current = () => generation === this.generation && this.state !== "stopped";
         let ready = false;
         this.state = "connecting";
+        // A RECONNECT waits for `ready` too (the first open has `start`'s own timer): a socket that
+        // opens and never says ready used to leave the feed "connecting" for good, hearing nothing.
+        const readyTimer = first
+            ? undefined
+            : this.setTimer(() => {
+                if (!current() || ready)
+                    return;
+                this.log(`feed for ${this.deps.session} did not say ready within ${(this.deps.readyTimeoutMs ?? READY_TIMEOUT_MS) / 1000}s`);
+                const socket = this.socket;
+                this.generation++;
+                this.socket = undefined;
+                try {
+                    socket?.close(1000, "No ready");
+                }
+                catch {
+                    /* Already gone. */
+                }
+                this.scheduleReconnect("did not say ready");
+            }, this.deps.readyTimeoutMs ?? READY_TIMEOUT_MS);
         try {
             this.socket = this.deps.connect(ticket.url, ticket.protocols, {
                 onOpen: () => { },
@@ -144,8 +169,11 @@ class ChannelFeed {
                         this.cursor = frame.cursor;
                     if (frame.type === "ready") {
                         ready = true;
+                        if (readyTimer !== undefined)
+                            this.clearTimer(readyTimer);
                         this.state = "open";
                         this.attempt = 0;
+                        this.log(`feed for ${this.deps.session} ready`);
                         first?.onReady();
                         return;
                     }
@@ -158,7 +186,10 @@ class ChannelFeed {
                 onClose: (code, reason) => {
                     if (!current())
                         return;
+                    if (readyTimer !== undefined)
+                        this.clearTimer(readyTimer);
                     this.socket = undefined;
+                    this.log(`feed for ${this.deps.session} closed ${code}${reason ? ` (${reason})` : ""}`);
                     if (!ready && first) {
                         first.onFailBeforeReady(`The BayChat feed closed before it was ready (${code}${reason ? `: ${reason}` : ""}).`);
                         return;
@@ -168,6 +199,7 @@ class ChannelFeed {
                         // listener for this session. Reconnecting would fight whichever replaced it.
                         this.log(`feed for ${this.deps.session} stopped by the server (${reason || code})`);
                         this.stop();
+                        void this.pushStopped(`the server stopped this feed (${reason || code}) — another listener for this session replaced it, or it was ended`);
                         return;
                     }
                     this.scheduleReconnect(`closed ${code}${reason ? `: ${reason}` : ""}`);
@@ -185,6 +217,12 @@ class ChannelFeed {
     scheduleReconnect(why) {
         if (this.state === "stopped")
             return;
+        if (this.attempt >= exports.MAX_FAILED_RECONNECTS) {
+            this.log(`feed for ${this.deps.session} gave up after ${this.attempt} failed reconnects (${why})`);
+            this.stop();
+            void this.pushStopped(`${this.attempt} reconnects in a row failed (last: ${why})`);
+            return;
+        }
         this.state = "retrying";
         const delay = exports.BACKOFF_MS[Math.min(this.attempt, exports.BACKOFF_MS.length - 1)];
         this.attempt++;
@@ -204,14 +242,14 @@ class ChannelFeed {
         if (this.stopped())
             return;
         if (minted.ok) {
+            this.log(`feed for ${this.deps.session} minted a ticket; opening`);
             this.open(minted.ticket);
             return;
         }
+        this.log(`feed for ${this.deps.session} could not mint a ticket${minted.fatal ? " (final)" : ""}: ${minted.detail}`);
         if (minted.fatal) {
             this.stop();
-            await this.deps.push(`BayChat stopped listening for session "${this.deps.session}": ${minted.detail} ` +
-                `If the session expired, call join_session again with the same name and room, then call ` +
-                `this BayChat channel's listen tool again. Until then this session does not hear the Bay.`, this.meta({ event: "stopped" }));
+            await this.pushStopped(minted.detail);
             return;
         }
         this.scheduleReconnect(`could not reconnect (${minted.detail})`);
@@ -309,6 +347,12 @@ class ChannelFeed {
             message_ids: c.messageId,
         }));
     }
+    /** The feed is over and will not come back by itself: say so, and what to do. */
+    async pushStopped(detail) {
+        await this.deps.push(`BayChat stopped listening for session "${this.deps.session}": ${detail}. ` +
+            `If the session expired, call join_session again with the same name and room, then call ` +
+            `this BayChat channel's listen tool again. Until then this session does not hear the Bay.`, this.meta({ event: "stopped" }));
+    }
     async pushReset() {
         await this.deps.push(`BayChat reset the feed for session "${this.deps.session}". Catch up on your joined conversations with get_messages; ` +
             `a reset never means there were no messages. The channel stays open.`, this.meta({ event: "reset" }));

package/dist/channel/log-file.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.channelLogFile = channelLogFile;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../config");
+/**
+ * The channel's own log, `~/.baychat/channel.log` (2026-10-23). Claude Code swallows a channel
+ * server's stderr, so when a feed went quiet there was nothing to read afterwards. Every state
+ * change, close code and reason, and ticket mint is written here with the time and process id.
+ *
+ * Kept small: past `maxBytes` the file moves to `channel.log.1` (one old file, replaced each
+ * time). Owner-only (0600): it names sessions and Bays. Never throws — a log that cannot be
+ * written must not take the channel down with it.
+ */
+function channelLogFile(dir = (0, config_1.configDir)(), maxBytes = 1_000_000) {
+    const file = node_path_1.default.join(dir, "channel.log");
+    return (line) => {
+        try {
+            node_fs_1.default.mkdirSync(dir, { recursive: true, mode: 0o700 });
+            try {
+                if (node_fs_1.default.statSync(file).size > maxBytes)
+                    node_fs_1.default.renameSync(file, `${file}.1`);
+            }
+            catch {
+                /* No file yet. */
+            }
+            node_fs_1.default.appendFileSync(file, `${new Date().toISOString()} [${process.pid}] ${line}\n`, { mode: 0o600 });
+        }
+        catch {
+            /* Best effort: stderr still has the line. */
+        }
+    };
+}

package/dist/channel/server.js

@@ -71,6 +71,7 @@ const ws_1 = require("../relay/ws");
 const claude_link_1 = require("./claude-link");
 const detect_1 = require("./detect");
 const feed_1 = require("./feed");
+const log_file_1 = require("./log-file");
 const permission_1 = require("./permission");
 const relay_link_1 = require("./relay-link");
 /** Delivered to Claude as context when this server connects. */
@@ -213,6 +214,38 @@ async function mintTicket(deps, { bay, session, cursor, commands }) {
     }
     catch (err) {
         const status = httpStatus(err);
+        // The Bay requires two-step login and this person has not set it up (API
+        // mfa-policy.service.ts, 403 MFA_REQUIRED). Logging in again would not help; setting it up
+        // does, and the same computer login works again the moment it is done.
+        const said = err instanceof Error ? err.message : String(err);
+        // Bay rules about terminal agents (API docs/features/TERMINAL_RULES.md, AGENTS_PAGE.md):
+        // each says what to do, none of them is fixed by logging in again.
+        if (status === 403 && /TERMINAL_AGENTS_PAUSED/.test(said)) {
+            return { ok: false, fatal: true, detail: "Stopped: the admins of this Bay paused terminal agents. Ask them to switch it back on, then start this session again." };
+        }
+        if (status === 403 && /DEVICE_PENDING_APPROVAL/.test(said)) {
+            return { ok: false, fatal: true, detail: "Stopped: this computer is waiting for a Bay admin to approve it (Settings → Agents in this Bay). Start this session again once it is approved." };
+        }
+        if (status === 403 && /AGENT_DISABLED/.test(said)) {
+            return { ok: false, fatal: true, detail: "Stopped: this session was switched off in BayChat. You or a Bay admin can switch it on in Settings → Agents in this Bay." };
+        }
+        if (status === 403 && /MFA_REQUIRED/.test(said)) {
+            return {
+                ok: false,
+                fatal: true,
+                detail: "Stopped: this Bay requires two-step login. Set it up in the BayChat app (Settings → Two-step login), " +
+                    "then start this session again.",
+            };
+        }
+        // "Company sign-in only" (API sso-gate.service.ts): this computer's login was not approved
+        // from the Bay's company sign-in. Logging in again, approved from one, fixes it.
+        if (status === 403 && /SSO_REQUIRED/.test(said)) {
+            return {
+                ok: false,
+                fatal: true,
+                detail: "Stopped: this Bay requires company sign-in. Run `baychat login` again and approve it while signed in with your company account.",
+            };
+        }
         if (status === 401 || status === 403) {
             return { ok: false, fatal: true, detail: "BayChat refused this computer's login. Run `baychat login`." };
         }
@@ -259,7 +292,9 @@ class ChannelService {
             bayName = this.deps.login(bay).bayName;
         }
         catch (err) {
-            return toolResult("failed", `Failed: ${err instanceof Error ? err.message : String(err)} Use listen_messages and a native Monitor instead.`, { session });
+            const detail = err instanceof Error ? err.message : String(err);
+            this.deps.log(`listen ${session}: sign-in failed: ${detail}`);
+            return toolResult("failed", `Failed: ${detail} Use listen_messages and a native Monitor instead.`, { session, stage: "login", detail });
         }
         const key = `${bayName ?? ""}\u0000${session}`;
         this.feeds.get(key)?.stop();
@@ -304,7 +339,8 @@ class ChannelService {
             this.closeCommandLink(key, link);
             if (this.last?.key === key)
                 this.last = undefined;
-            return toolResult("failed", `Failed: ${started.detail} Use listen_messages and a native Monitor instead.`, { session });
+            this.deps.log(`listen ${session}: the feed did not start: ${started.detail}`);
+            return toolResult("failed", `Failed: ${started.detail} Use listen_messages and a native Monitor instead.`, { session, stage: "feed", detail: started.detail });
         }
         this.last = { key, session, bay };
         // Approvals for `baychat claude` / `baychat start` (approve-hook --session-from-claude): this
@@ -398,7 +434,12 @@ const PermissionRequestSchema = zod_1.z.object({
 });
 /** Boot on stdio and block on the transport. */
 async function startChannelServer(deps) {
-    const log = deps?.log ?? ((line) => console.error(`[baychat channel] ${line}`));
+    const toFile = (0, log_file_1.channelLogFile)();
+    const log = deps?.log ??
+        ((line) => {
+            console.error(`[baychat channel] ${line}`);
+            toFile(line);
+        });
     const mcp = new index_js_1.Server({ name: detect_1.CHANNEL_MCP_ENTRY, version: "1" }, {
         // `claude/channel/permission`: Claude Code also offers this channel its tool-approval
         // dialogs (permission.ts). Safe to declare because only the session's owner can answer the

package/dist/claude-context-flush.js

@@ -45,6 +45,8 @@ const claude_context_state_1 = require("./claude-context-state");
 const config_1 = require("./config");
 const context_report_1 = require("./context-report");
 const registry_1 = require("./relay/registry");
+const runtime_limits_1 = require("./relay/runtime-limits");
+const api_1 = require("./api");
 /**
  * The most recent BayChat tool call in the transcript tail that names a session.
  *
@@ -121,15 +123,26 @@ function acquireLock(file, now) {
         return false;
     }
 }
-/** Remove what was handled, re-reading first so a sample noted meanwhile is not lost. */
-function settle(sid, handled, patch) {
+/**
+ * Remove what was handled, re-reading first so a sample noted meanwhile is not lost. `limitsDone`:
+ * the limits report with this key was attempted — dropped unless a newer one was noted since.
+ */
+function settle(sid, handled, patch, limitsDone) {
     const state = (0, claude_context_state_1.readState)(sid);
     state.queue = state.queue.filter((q) => !handled.has(q.id));
-    (0, claude_context_state_1.writeState)({ ...state, ...patch, queue: state.queue });
+    const limits = state.limits && limitsDone !== undefined && (0, runtime_limits_1.limitsKey)(state.limits) === limitsDone ? undefined : state.limits;
+    (0, claude_context_state_1.writeState)({ ...state, ...patch, queue: state.queue, limits });
 }
 /** `baychat context-flush --claude <id>`: send what the status line and hooks noted. */
 async function runContextFlush(argv, deps = {}) {
-    const d = { now: Date.now, post: context_report_1.postContextEvent, loadDevice: config_1.loadDeviceCredentials, identify: identifySession, ...deps };
+    const d = {
+        now: Date.now,
+        post: context_report_1.postContextEvent,
+        postLimits: runtime_limits_1.postSessionLimits,
+        loadDevice: config_1.loadDeviceCredentials,
+        identify: identifySession,
+        ...deps,
+    };
     const i = argv.indexOf("--claude");
     const sid = (0, claude_context_state_1.safeId)(i >= 0 ? argv[i + 1] : undefined);
     if (!sid)
@@ -140,7 +153,7 @@ async function runContextFlush(argv, deps = {}) {
     try {
         for (let round = 0; round < 5; round++) {
             const state = (0, claude_context_state_1.readState)(sid);
-            if (state.queue.length === 0)
+            if (state.queue.length === 0 && !state.limits)
                 return 0;
             if ((0, claude_context_state_1.backoffUntil)() > d.now())
                 return 0;
@@ -157,14 +170,14 @@ async function runContextFlush(argv, deps = {}) {
                 // grow. Said once per Claude session, in the log.
                 if (!state.unidentifiedAt)
                     (0, claude_context_state_1.logContextError)(`Claude session ${sid} is not joined to BayChat as far as this machine can prove — not reporting its context`);
-                settle(sid, all, { unidentifiedAt: d.now(), baychatSession: undefined, identifiedAt: undefined });
+                settle(sid, all, { unidentifiedAt: d.now(), baychatSession: undefined, identifiedAt: undefined }, state.limits && (0, runtime_limits_1.limitsKey)(state.limits));
                 return 0;
             }
             const identityPatch = { baychatSession: identity.session, conversationId: identity.conversationId, identifiedAt: d.now(), unidentifiedAt: undefined };
             const device = d.loadDevice();
             if (!device) {
                 (0, claude_context_state_1.logContextError)("not logged in to BayChat (`baychat login`) — context not reported");
-                settle(sid, all, identityPatch);
+                settle(sid, all, identityPatch, state.limits && (0, runtime_limits_1.limitsKey)(state.limits));
                 return 0;
             }
             const handled = new Set();
@@ -200,7 +213,17 @@ async function runContextFlush(argv, deps = {}) {
                 settle(sid, handled, identityPatch);
                 return 0;
             }
-            settle(sid, handled, identityPatch);
+            // The plan's limits (TERMINAL_CREDITS.md): one attempt, whatever happens — the next status
+            // line brings a newer report within minutes, so nothing here is worth keeping or retrying.
+            let limitsDone;
+            if (state.limits) {
+                limitsDone = (0, runtime_limits_1.limitsKey)(state.limits);
+                const outcome = await d.postLimits({ baseUrl: device.baseUrl, token: device.token }, identity.session, state.limits, api_1.apiRequest);
+                if (outcome.kind === "refused" || outcome.kind === "failed") {
+                    (0, claude_context_state_1.logContextError)(`could not report plan limits for "${identity.session}": ${outcome.message}`);
+                }
+            }
+            settle(sid, handled, identityPatch, limitsDone);
         }
         return 0;
     }

package/dist/claude-context.js

@@ -76,6 +76,7 @@ const claude_context_flush_1 = require("./claude-context-flush");
 const claude_context_state_1 = require("./claude-context-state");
 const claude_settings_1 = require("./claude-settings");
 const context_report_1 = require("./context-report");
+const runtime_limits_1 = require("./relay/runtime-limits");
 // The state helpers and the sender live beside this file; re-exported so callers and tests have
 // one module to import from.
 var claude_context_state_2 = require("./claude-context-state");
@@ -165,17 +166,30 @@ function noteStatus(raw, deps) {
     }
     const sid = (0, claude_context_state_1.safeId)(status?.session_id);
     const sample = (0, context_report_1.claudeUsageFromStatus)(status);
-    if (!sid || !sample)
+    // The plan's limits and running cost ride the same line (TERMINAL_CREDITS.md).
+    const limits = (0, runtime_limits_1.claudeLimitsFromStatus)(status);
+    if (!sid || (!sample && !limits))
         return false;
-    const autoCompactAt = (0, context_report_1.claudeAutoCompactAt)(sample.size, autoCompactOverride(deps.env));
     const now = deps.now();
     const state = (0, claude_context_state_1.readState)(sid);
     if (state.unidentifiedAt && now - state.unidentifiedAt < claude_context_state_1.UNIDENTIFIED_RETRY_MS)
         return false;
-    if (!(0, context_report_1.usageDue)(state.lastQueued, { ...sample, autoCompactAt }, now))
+    let queued = false;
+    if (sample) {
+        const autoCompactAt = (0, context_report_1.claudeAutoCompactAt)(sample.size, autoCompactOverride(deps.env));
+        if ((0, context_report_1.usageDue)(state.lastQueued, { ...sample, autoCompactAt }, now)) {
+            (0, claude_context_state_1.enqueue)(state, { runtime: "claude-code", event: "usage", used: sample.used, size: sample.size, autoCompactAt, source: "exact" });
+            state.lastQueued = { ...sample, autoCompactAt, at: now };
+            queued = true;
+        }
+    }
+    if (limits && (0, runtime_limits_1.limitsDue)(state.lastLimits, limits, now)) {
+        state.limits = limits;
+        state.lastLimits = { key: (0, runtime_limits_1.limitsKey)(limits), at: now };
+        queued = true;
+    }
+    if (!queued)
         return false;
-    (0, claude_context_state_1.enqueue)(state, { runtime: "claude-code", event: "usage", used: sample.used, size: sample.size, autoCompactAt, source: "exact" });
-    state.lastQueued = { ...sample, autoCompactAt, at: now };
     if (typeof status.transcript_path === "string")
         state.transcriptPath = status.transcript_path;
     (0, claude_context_state_1.writeState)(state);

package/dist/claude-onboarding.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BAY_CHOICE = exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = void 0;
+exports.BAY_CHOICE = exports.CLAUDE_REACHABILITY = exports.CLAUDE_JOIN_STEPS = exports.CANNOT_WAKE_SENTENCE = exports.CHAT_LISTENING_SENTENCE = void 0;
+/** What a chat-app session says once it listens: it hears the Bay only while the chat is open.
+ * Word for word the API's join result (apps/api/src/mcp/session-tools.ts). */
+exports.CHAT_LISTENING_SENTENCE = "I'm listening while this chat is open; for 24/7 a terminal or VPS agent is the right place.";
+/** What a session with no listening tool at all says, instead of failing silently or claiming
+ * it is connected. Word for word the API's join result (apps/api/src/mcp/session-tools.ts). */
+exports.CANNOT_WAKE_SENTENCE = "This chat can't be woken by new BayChat messages. I'll read them when you write to me here, or ask me to check BayChat.";
 /** Claude's native entry point. An expired local relay login says nothing about a separately configured MCP connection. */
 exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native Monitor** (a WebSocket, or behind an HTTPS proxy a command). Search deferred tools once
    if needed, for \`join_session\`, \`listen_messages\`, \`get_delivery_status\`,
@@ -17,15 +23,16 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native Monitor** (a W
 2. Preserve the requested name and the exact group title or id. For automatic naming, run
    only \`baychat session-name --runtime claude\` to obtain the verified name.
    A bare invocation lists sessions and stops; it never joins.
-   For a supplied name call \`join_session({session: "<name>", sessions: true})\`.
+   For a supplied name alone call \`join_session({session: "<name>"})\`: your private chat with your owner.
    For a supplied group use \`join_session({session: "<name>", group: "<exact title or id>"})\`.
-   For explicit \`--private\`, omit both \`sessions\` and \`group\`.
+   For explicit \`--sessions\`, pass \`sessions: true\` (the shared Sessions group).
    When the owner explicitly asks to CREATE a group, instead call
    \`create_group({session: "<name>", title: "<exact title>"})\`: it creates the session and joins it in one call.
    Do not ask again when the owner already requested creation. A supplied group title
    also authorizes creation on GROUP_NOT_FOUND (a group id never does); never substitute a similarly named group.
    If blocked, state the exact requested title and needed action in your reply.
-3. **Channel first.** If BayChat's channel \`listen\` tool exists
+3. **Start listening now, without asking. Joining is not finished until this step is done**;
+   never ask whether to start the listener. **Channel first.** If BayChat's channel \`listen\` tool exists
    (\`mcp__plugin_baychat_channel__listen\` from the plugin, or
    \`mcp__baychat_channel__listen\`), call it with \`{session: "<confirmed name>"}\`
    (add \`bay: "<Bay>"\` when the session joined a Bay other than the default).
@@ -34,7 +41,8 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native Monitor** (a W
    channel's feed. Go to step 4. If it answers inactive or failed, or the tool is
    absent, use the Monitor instead:
    call \`listen_messages({session: "<confirmed name>"})\`. Pass its returned
-   \`monitor\` object directly to the native **Monitor** tool: it contains
+   \`monitor\` object directly to the native **Monitor** tool (or whatever native
+   WebSocket/event-stream tool this host has): it contains
    \`ws: {url, protocols}\` and \`timeout_ms\`. If your Monitor offers a
    \`persistent\` option, also set \`persistent: true\`. Keep its ticket private.
    **Behind an HTTPS proxy** (\`HTTPS_PROXY\` is set in your environment, or the
@@ -47,6 +55,9 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native Monitor** (a W
 4. Call \`get_delivery_status({session: "<confirmed name>"})\`. Only \`connected\`
    confirms incoming delivery. \`awaiting_connection\` means a ticket was created
    but Monitor has not connected; show that exact state, not "ready".
+   In a chat app (not a terminal), once connected say once: "${exports.CHAT_LISTENING_SENTENCE}"
+   **With no channel \`listen\` and no Monitor-like tool at all**, never claim
+   connected; tell the user: "${exports.CANNOT_WAKE_SENTENCE}"
    Print the confirmed name and room. Use that name as \`session\` on every
    later BayChat tool call. Read one \`get_messages\` batch with \`limit: 10\`;
    say hello once in the confirmed conversation unless already greeted.
@@ -58,11 +69,11 @@ exports.CLAUDE_JOIN_STEPS = `1. Use **remote BayChat MCP + native Monitor** (a W
   different logins. Do not diagnose both as down from one file.
 - For login or missing tools, use Automatic setup above; the session runs the
   terminal commands itself. Keep credentials inside the CLI and MCP client.
-- Native Monitor requires a supported Claude Code host (WebSocket sources are
+- Native Monitor requires a supported host (in Claude Code, WebSocket sources are
   documented from 2.1.195). If the tool is missing or denied, or neither \`ws\`
-  nor \`monitor_command\` connects, explain that incoming delivery is not
-  connected and show the specific host limitation. Stop there; do not write
-  your own shell listener or start local MCP or a relay fallback.
+  nor \`monitor_command\` connects, say incoming delivery is not connected and
+  why (with no listening tool at all, the sentence in step 4). Stop there; do not
+  write your own shell listener or start local MCP or a relay fallback.
 `;
 /** Native socket lifecycle, including the intentional-stop boundary. */
 exports.CLAUDE_REACHABILITY = `## Staying reachable — native remote messages
@@ -94,7 +105,9 @@ arrived. That is the runtime's limit, not a stop: **every time it happens, and o
 any other close**, call \`listen_messages\` with this session and the last cursor
 (from \`ready\`, \`messages\` or \`closed\`), open one replacement Monitor the same way
 (\`ws\` or \`monitor_command\`), and confirm
-\`get_delivery_status\` again. The reopened feed replays what it missed, so no
+\`get_delivery_status\` again. Do it yourself, without asking. A BayChat restart
+(close **1012**, or \`listen_messages\` failing) is the same: retry after 5 s, 30 s,
+then every 2 minutes until it connects. The reopened feed replays what it missed, so no
 \`get_messages\` catch-up is needed unless a \`reset\` arrives. Skipping this
 leaves the session deaf to the Bay with its terminal still open.
 Keep the last cursor in this conversation; do not save tickets in files.

package/dist/cli-help.js

@@ -140,6 +140,9 @@ Usage:
                                         came from, so "we can wake this headlessly"
                                         is a claim you can check
   baychat relay stop                    Stop the relay and disable it at boot
+  baychat relay log <session> [-f]      What a Codex session the relay runs did: its
+                                        commands, file changes, answers and approval
+                                        cards. -f keeps following it
   baychat doctor [--json]               Check every link between this machine and
                                         BayChat — credential, relay, and per runtime
                                         its MCP registration, skill, executable and

package/dist/client-paths.js

@@ -111,7 +111,8 @@ function claudeDesktopPaths(env) {
 function configPathFor(client, env) {
     switch (client) {
         case "codex":
-            return `${env.home}/.codex/config.toml`;
+            // `$CODEX_HOME` is where Codex reads, when it is set — never the home directory's copy.
+            return env.codexHome ? node_path_1.default.join(env.codexHome, "config.toml") : `${env.home}/.codex/config.toml`;
         case "cursor":
             return `${env.home}/.cursor/mcp.json`;
         case "desktop":
@@ -152,6 +153,7 @@ function currentPathEnv() {
         localAppData: process.env.LOCALAPPDATA,
         listDirs: listDirsOnDisk,
         xdgConfigHome: process.env.XDG_CONFIG_HOME,
+        codexHome: process.env.CODEX_HOME || undefined,
     };
 }
 /**
@@ -193,6 +195,9 @@ function configPathsFor(client, env) {
     if (client === "desktop")
         return claudeDesktopPaths(env);
     const canonical = configPathFor(client, env);
+    // An explicit CODEX_HOME is the one place that Codex reads; a snap copy is not guessed beside it.
+    if (client === "codex" && env.codexHome && canonical)
+        return [canonical];
     const paths = [];
     const snap = snapConfigPath(client, env);
     if (snap)

package/dist/client-scope.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isolatedLoginReason = isolatedLoginReason;
+exports.isolatedLoginNotice = isolatedLoginNotice;
+const config_1 = require("./config");
+/**
+ * Why this login must leave the computer's agent clients alone — or undefined when it is the
+ * computer's own login and may refresh them.
+ *
+ * The clients' configs are GLOBAL: `~/.claude.json`, Claude Desktop's config, Codex's
+ * `config.toml`, `~/.cursor/mcp.json`. They belong to the computer's default BayChat login. A
+ * login made with `BAYCHAT_CONFIG_DIR` set (a second setup, a QA relay) or against another server
+ * (`--base`, `BAYCHAT_API_URL`) used to rewrite all of them to ITS server and token on
+ * `baychat login --finish`, `baychat bays default` and `baychat update` — silently moving every
+ * agent on the computer to a different BayChat (found 2026-10-23). Such a login now saves its own
+ * credential and says how to connect a client to it on purpose (`baychat connect <client>`).
+ */
+function isolatedLoginReason(baseUrl, env = process.env) {
+    // The deliberate way back, for a person whose own clients DO belong to this setup.
+    if (env.BAYCHAT_REFRESH_CLIENTS === "1")
+        return undefined;
+    if (env.BAYCHAT_CONFIG_DIR)
+        return `BAYCHAT_CONFIG_DIR is set (${env.BAYCHAT_CONFIG_DIR})`;
+    const norm = (url) => url.trim().replace(/\/+$/, "").toLowerCase();
+    if (norm(baseUrl) !== norm(config_1.DEFAULT_API_URL))
+        return `this login is for ${baseUrl}, not ${config_1.DEFAULT_API_URL}`;
+    return undefined;
+}
+/** The line printed instead of touching the clients. */
+function isolatedLoginNotice(reason) {
+    return (`  Your agent clients (Claude Code, Claude Desktop, Codex, Cursor) were left as they are: ${reason}. ` +
+        "To use this login in one of them, run `baychat connect <client>` with the same settings " +
+        "(or set BAYCHAT_REFRESH_CLIENTS=1 if every client on this computer should follow this login).");
+}

package/dist/codex-onboarding.js

@@ -17,8 +17,8 @@ exports.CODEX_JOIN_STEPS = `1. Preserve BOTH arguments. The first argument is th
 3. Join with ONE MCP call, \`join_session\`, passing \`runtime: "codex"\` and \`threadId\`
    (the value from step 2). For \`$baychat codex "vps_baychat"\` call exactly:
    \`join_session({ session: "codex", group: "vps_baychat", runtime: "codex", threadId: "<CODEX_THREAD_ID>" })\`
-   With only a chosen name pass \`sessions: true\` instead of \`group\`. With \`--private\`
-   pass neither. For automatic naming run \`baychat session-name --runtime codex\` (local,
+   With only a chosen name pass neither \`group\` nor \`sessions\` (your private chat with your
+   owner). With \`--sessions\` pass \`sessions: true\` instead of \`group\`. For automatic naming run \`baychat session-name --runtime codex\` (local,
    sandbox-safe) and use the name it prints, with \`group: "<title>"\` or \`sessions: true\`.
    Do not drop the name, swap the arguments, or join Sessions when a group was supplied.
    A bare invocation lists sessions and stops.