baychat 0.25.3 → 0.27.0

package/dist/relay/bay-relays.js

@@ -0,0 +1,224 @@
+"use strict";
+// One relay connection per Bay login (docs/features/MULTI_BAY_DEVICE_LOGIN.md).
+//
+// THE DESIGN, AND WHY IT IS THIS ONE. The relay daemon (daemon.ts) holds one device login's
+// event feed and keys everything it knows — registry, held messages, carried briefs, the
+// attach socket, the mailbox — by SESSION NAME. A second Bay on the same computer may well
+// have a session with the same name. Re-keying ~1,900 lines of daemon by (Bay, name) would
+// touch every delivery path at once.
+//
+// Instead each NON-default Bay gets its own, unmodified daemon, in a child process whose whole
+// world is scoped to that Bay by environment:
+//
+//   BAYCHAT_CONFIG_DIR    <config>/bays/<bayId>     its registry, held store, cursors, pid
+//   BAYCHAT_RELAY_SOCKET  …baychat-relay-<id>.sock  its own attach socket (named pipe on Windows)
+//   BAYCHAT_MAILBOX_DIR   <config>/bays/<bayId>/mailbox
+//   BAYCHAT_DEVICE_TOKEN  that Bay's token           so its feed is that Bay's, and only that Bay's
+//
+// So the registry is keyed by (Bay, session name) by construction: two Bays, two registries.
+// The DEFAULT Bay's daemon is the one that always ran, in the parent process, with the paths
+// it always used — a one-Bay computer runs exactly what it ran before and spawns nothing.
+//
+// A session that joined another Bay (`baychat join --bay Harbor`) applies the same scope to
+// its own process before it attaches, so it finds that Bay's socket and mailbox.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BayRelaySupervisor = exports.BAY_RELAY_PARENT_ENV = exports.BAY_RELAY_CHILD_ENV = void 0;
+exports.bayRelayScope = bayRelayScope;
+exports.bayClientEnv = bayClientEnv;
+exports.bayRelayEnv = bayRelayEnv;
+exports.isBayRelayChild = isBayRelayChild;
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const socket_1 = require("./socket");
+/** Set in a per-Bay child relay: it must never supervise children of its own. */
+exports.BAY_RELAY_CHILD_ENV = "BAYCHAT_RELAY_BAY";
+/** The supervising relay's pid, so an orphaned child can stop itself. */
+exports.BAY_RELAY_PARENT_ENV = "BAYCHAT_RELAY_PARENT_PID";
+/** What a Bay id may contribute to a path or pipe name. */
+function safeId(bayId) {
+    return bayId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 40) || "bay";
+}
+/**
+ * Where one Bay's relay keeps everything, derived from the DEFAULT relay's own locations so a
+ * custom `BAYCHAT_CONFIG_DIR` or `BAYCHAT_RELAY_SOCKET` carries over.
+ */
+function bayRelayScope(bayId, baseConfigDir, baseSocket) {
+    const id = safeId(bayId);
+    const configDir = path.join(baseConfigDir, "bays", id);
+    let socket;
+    if ((0, socket_1.isNamedPipe)(baseSocket))
+        socket = `${baseSocket}-${id}`;
+    else if (baseSocket.endsWith(".sock"))
+        socket = `${baseSocket.slice(0, -".sock".length)}-${id}.sock`;
+    else
+        socket = `${baseSocket}-${id}`;
+    return { bayId, configDir, socket, mailboxDir: path.join(configDir, "mailbox") };
+}
+/** The environment that points a CLIENT (attach, status) at one Bay's relay. */
+function bayClientEnv(scope) {
+    return {
+        BAYCHAT_CONFIG_DIR: scope.configDir,
+        BAYCHAT_RELAY_SOCKET: scope.socket,
+        BAYCHAT_MAILBOX_DIR: scope.mailboxDir,
+    };
+}
+/** The environment a per-Bay CHILD relay runs with. Holds the Bay's token: never logged. */
+function bayRelayEnv(bay, baseUrl, scope, parentPid) {
+    return {
+        ...bayClientEnv(scope),
+        BAYCHAT_DEVICE_TOKEN: bay.token,
+        BAYCHAT_API_URL: baseUrl,
+        BAYCHAT_NO_RELAY_AUTOSTART: "1",
+        [exports.BAY_RELAY_CHILD_ENV]: bay.bayId,
+        [exports.BAY_RELAY_PARENT_ENV]: String(parentPid),
+    };
+}
+/** Is THIS process a per-Bay child relay? */
+function isBayRelayChild(env = process.env) {
+    return Boolean(env[exports.BAY_RELAY_CHILD_ENV]);
+}
+/**
+ * Keeps one child relay running per NON-default Bay login, and none for a one-Bay computer.
+ *
+ * `sync()` is the whole policy: wanted = the non-default Bays (only with two or more); a child
+ * whose Bay is no longer wanted, or whose token changed (a renewal), is stopped; a wanted Bay
+ * without a child gets one. A child that dies is restarted on a later sync, after a delay —
+ * never in a tight loop.
+ */
+class BayRelaySupervisor {
+    deps;
+    running = new Map();
+    lastExit = new Map();
+    timer;
+    stopped = false;
+    log;
+    spawnChild;
+    now;
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.log ?? ((line) => console.error(`[relay] ${line}`));
+        this.spawnChild = deps.spawn ?? defaultSpawn;
+        this.now = deps.now ?? Date.now;
+    }
+    start() {
+        this.sync();
+        this.timer = setInterval(() => this.sync(), this.deps.intervalMs ?? 30_000);
+        this.timer.unref?.();
+    }
+    /** The Bays a child relay is running for — for status and tests. */
+    bays() {
+        return [...this.running.keys()].sort();
+    }
+    sync() {
+        if (this.stopped)
+            return;
+        const bays = this.deps.loadBays();
+        const baseUrl = this.deps.baseUrl();
+        const wanted = new Map();
+        if (baseUrl && bays.length > 1)
+            for (const b of bays)
+                if (!b.isDefault)
+                    wanted.set(b.bayId, b);
+        for (const [bayId, run] of this.running) {
+            const want = wanted.get(bayId);
+            if (!want || want.token !== run.token)
+                this.stopChild(bayId, want ? "login renewed" : "no longer a Bay login here");
+        }
+        for (const [bayId, bay] of wanted) {
+            if (this.running.has(bayId))
+                continue;
+            const exited = this.lastExit.get(bayId);
+            if (exited !== undefined && this.now() - exited < (this.deps.restartDelayMs ?? 10_000))
+                continue;
+            this.startChild(bay, baseUrl);
+        }
+    }
+    startChild(bay, baseUrl) {
+        const scope = bayRelayScope(bay.bayId, this.deps.baseConfigDir, this.deps.baseSocket);
+        let child;
+        try {
+            child = this.spawnChild(bayRelayEnv(bay, baseUrl, scope, process.pid));
+        }
+        catch (err) {
+            this.lastExit.set(bay.bayId, this.now());
+            this.log(`could not start the relay for Bay "${bay.bayName}": ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        const run = { child, token: bay.token, stopping: false };
+        this.running.set(bay.bayId, run);
+        this.log(`relay for Bay "${bay.bayName}" started (pid ${child.pid ?? "?"})`);
+        child.on("exit", (code) => {
+            if (this.running.get(bay.bayId) === run)
+                this.running.delete(bay.bayId);
+            if (!run.stopping) {
+                this.lastExit.set(bay.bayId, this.now());
+                this.log(`relay for Bay "${bay.bayName}" exited (${code ?? "signal"}); it is restarted shortly`);
+            }
+        });
+        child.on("error", (err) => {
+            this.log(`relay for Bay "${bay.bayName}": ${err.message}`);
+        });
+    }
+    stopChild(bayId, why) {
+        const run = this.running.get(bayId);
+        if (!run)
+            return;
+        run.stopping = true;
+        this.running.delete(bayId);
+        this.log(`stopping the relay for Bay ${bayId} (${why})`);
+        try {
+            run.child.kill("SIGTERM");
+        }
+        catch (err) {
+            this.log(`could not stop the relay for Bay ${bayId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        for (const bayId of [...this.running.keys()])
+            this.stopChild(bayId, "relay stopping");
+    }
+}
+exports.BayRelaySupervisor = BayRelaySupervisor;
+/** Run this same CLI as `relay start --foreground`, in the Bay's scope. */
+function defaultSpawn(env) {
+    return (0, node_child_process_1.spawn)(process.execPath, [process.argv[1] ?? "", "relay", "start", "--foreground"], {
+        env: { ...process.env, ...env },
+        stdio: ["ignore", "inherit", "inherit"],
+    });
+}

package/dist/relay/commands.js

@@ -37,6 +37,7 @@ exports.cmdRelayStart = cmdRelayStart;
 exports.ensureRelayInstalled = ensureRelayInstalled;
 exports.tryRelayStatus = tryRelayStatus;
 exports.registerAcpSession = registerAcpSession;
+exports.useBayRelay = useBayRelay;
 exports.cmdRelayStatus = cmdRelayStatus;
 exports.cmdRelayStop = cmdRelayStop;
 exports.shouldFallBackToMailbox = shouldFallBackToMailbox;
@@ -61,6 +62,8 @@ const terminal_pane_1 = require("./terminal-pane");
 const owner_pid_1 = require("./owner-pid");
 const parent_watch_1 = require("./parent-watch");
 const daemon_1 = require("./daemon");
+const bay_relays_1 = require("./bay-relays");
+const config_1 = require("../config");
 const resume_1 = require("./resume");
 const mailbox_1 = require("./mailbox");
 const socket_1 = require("./socket");
@@ -119,13 +122,34 @@ function request(sock, frame, timeoutMs = 5_000) {
  */
 async function cmdRelayStart(opts = {}) {
     if (opts.foreground) {
-        const daemon = new daemon_1.RelayDaemon();
+        // One relay connection per Bay login (MULTI_BAY_DEVICE_LOGIN.md): this daemon is the
+        // DEFAULT Bay's, exactly as before; every other Bay login gets its own daemon in a child
+        // process scoped to that Bay. A per-Bay child supervises nothing and stops with its parent.
+        const child = (0, bay_relays_1.isBayRelayChild)();
+        const supervisor = child
+            ? undefined
+            : new bay_relays_1.BayRelaySupervisor({
+                loadBays: config_1.loadBayLogins,
+                baseUrl: () => (0, config_1.loadDeviceCredentials)()?.baseUrl ?? null,
+                baseConfigDir: (0, config_1.configDir)(),
+                baseSocket: (0, socket_1.socketPath)(),
+            });
+        const daemon = new daemon_1.RelayDaemon({ onListening: () => supervisor?.start() });
         const shutdown = () => {
+            supervisor?.stop();
             void daemon.stop().then(() => process.exit(0));
         };
         process.on("SIGINT", shutdown);
         process.on("SIGTERM", shutdown);
-        await daemon.start();
+        const parentPid = Number(process.env[bay_relays_1.BAY_RELAY_PARENT_ENV]);
+        if (child && Number.isInteger(parentPid) && parentPid > 1)
+            (0, parent_watch_2.watchParent)(parentPid, shutdown);
+        try {
+            await daemon.start();
+        }
+        finally {
+            supervisor?.stop();
+        }
         return;
     }
     if (await (0, socket_1.probeSocket)((0, socket_1.socketPath)())) {
@@ -229,6 +253,32 @@ async function registerAcpSession(frame) {
         throw err;
     }
 }
+/**
+ * Point THIS process's relay client calls (attach, status, mailbox registration) at one Bay's
+ * relay — the per-Bay child the supervising relay runs (bay-relays.ts). Used by a session that
+ * joined a non-default Bay. Call once, before the first relay call; the default Bay needs none.
+ */
+function useBayRelay(bayId) {
+    const scope = (0, bay_relays_1.bayRelayScope)(bayId, (0, config_1.configDir)(), (0, socket_1.socketPath)());
+    Object.assign(process.env, (0, bay_relays_1.bayClientEnv)(scope));
+}
+/** One line per non-default Bay login: is its relay answering? Empty for a one-Bay computer. */
+async function bayRelayLines() {
+    const bays = (0, config_1.loadBayLogins)();
+    if (bays.length < 2)
+        return [];
+    const lines = ["  Bay relays:"];
+    for (const bay of bays) {
+        if (bay.isDefault) {
+            lines.push(`    ${bay.bayName} (default) — this relay`);
+            continue;
+        }
+        const scope = (0, bay_relays_1.bayRelayScope)(bay.bayId, (0, config_1.configDir)(), (0, socket_1.socketPath)());
+        const alive = await (0, socket_1.probeSocket)(scope.socket);
+        lines.push(`    ${bay.bayName} — ${alive ? "running" : "NOT running (it starts within a minute of the relay; else restart the relay)"}`);
+    }
+    return lines;
+}
 async function cmdRelayStatus() {
     let status;
     try {
@@ -243,6 +293,8 @@ async function cmdRelayStatus() {
     console.log(`  polls: ${status.polls}   delivered: ${status.delivered}   cursor: ${status.cursor ?? "—"}`);
     if (status.lastError)
         console.log(`  last error: ${status.lastError}`);
+    for (const line of await bayRelayLines())
+        console.log(line);
     // Computed before the session list so a line can report its own last failure.
     const byName = new Map(status.sessions.map((s) => [s.name, s]));
     /**

package/dist/relay/daemon.js

@@ -178,8 +178,10 @@ class RelayDaemon {
      */
     binaries = new Map();
     log;
+    onListening;
     constructor(opts = {}) {
         this.log = opts.log ?? ((line) => console.log(`[relay] ${line}`));
+        this.onListening = opts.onListening;
         // EVERY candidate root, because the daemon cannot know which one the agent's
         // sandbox turned out to permit — it may have fallen back past the one this
         // process would have chosen.
@@ -317,6 +319,7 @@ class RelayDaemon {
             });
         });
         writePidFile();
+        this.onListening?.();
         // After the socket is ours: a relay refused as a duplicate must not keep sessions alive.
         this.acpKeepAlive = (0, daemon_glue_1.startAcpUpkeep)(this.acpAlive.run);
         this.codexContext.start();

package/dist/runtimes.js

@@ -192,6 +192,7 @@ ${ctx.invocation}
   the same for this session and differs for other sessions. If verification
   fails, ask the user for a name.
 - With neither a name nor \`--group\` nor \`--sessions\`: run \`list_sessions\` and stop.
+- With \`--bay <Bay>\`: join that Bay, through its own connection (see "Which Bay").
 
 ## The one rule that outranks everything else
 
@@ -206,6 +207,8 @@ Answering in the wrong room is the worst failure this feature has.
 
 ${help_topics_1.ROOMS_TOPIC}
 
+${claude_onboarding_1.BAY_CHOICE}
+
 ${ctx.runtime === "claude" || ctx.runtime === "codex" ? (0, session_setup_1.sessionSetupSteps)(ctx.runtime) : ""}
 
 ## Steps
@@ -364,7 +367,7 @@ exports.RUNTIME_SPECS = {
             frontmatter: true,
             render: (ctx) => renderCommand(ctx, true),
         },
-        invocation: '/baychat <name> ["<Group Title>"]',
+        invocation: '/baychat <name> ["<Group Title>"] [--bay <Bay>]',
         // Verified: `CLAUDE_CODE_SESSION_ID` is present in the environment of every
         // Bash tool call and equals the id of the transcript the session is writing,
         // which is exactly what `claude --resume` takes.
@@ -392,7 +395,7 @@ for a session that has genuinely ended, not the plan for one that is still open.
             frontmatter: true,
             render: (ctx) => renderCommand(ctx, true),
         },
-        invocation: '$baychat <name> ["<Group Title>"]',
+        invocation: '$baychat <name> ["<Group Title>"] [--bay <Bay>]',
         // NO `sessionIdExpr`, and the reason is not the one this comment used to give.
         //
         // Codex DOES export `$CODEX_THREAD_ID` — an attach on 2026-08-31 printed
@@ -510,7 +513,7 @@ DELIVERY PENDING and waits for a human — re-arm attach after every wake, witho
         // this copy SHADOWS a Codex skill a client already has — which would tell dsh to attach as
         // `--runtime codex`. It must be written here, never shared with the Codex file.
         command: { dir: ".dsh/skills/baychat", file: "SKILL.md", frontmatter: true, render: (ctx) => renderCommand(ctx, true) },
-        invocation: '/baychat <name> ["<Group Title>"]',
+        invocation: '/baychat <name> ["<Group Title>"] [--bay <Bay>]',
         relay: { runtime: "dsh", reArm: "background-every-wake", resumeNote: GENERIC_RESUME_NOTE },
         needsRestart: true,
     },

package/dist/session-command.js

@@ -5,6 +5,7 @@ exports.cmdJoinSession = cmdJoinSession;
 const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
 const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
 const config_1 = require("./config");
+const bays_1 = require("./bays");
 const session_name_1 = require("./session-name");
 const owner_pid_1 = require("./relay/owner-pid");
 const terminal_pane_1 = require("./relay/terminal-pane");
@@ -26,7 +27,8 @@ function parseJoinArgs(args) {
         if (argument.startsWith("--")) {
             if (argument !== "--group" &&
                 argument !== "--runtime" &&
-                argument !== "--session") {
+                argument !== "--session" &&
+                argument !== "--bay") {
                 throw new Error(`Unknown join option: ${argument}`);
             }
             const value = args[++index];
@@ -45,7 +47,7 @@ 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] [--bay Bay]");
     if (positionals[1] && options.group)
         throw new Error("Choose the group once, as a title or with --group.");
     if (options.session && positionals.length)
@@ -67,6 +69,11 @@ async function cmdJoinSession(args) {
     const device = (0, config_1.loadDeviceCredentials)();
     if (!device)
         throw new Error("Connect this computer once with baychat connect codex or baychat connect claude, then retry.");
+    // ONE LOGIN PER BAY: `--bay` picks which of this computer's logins the session joins with,
+    // and every call it makes uses that login — so it can only ever reach that Bay. With no
+    // `--bay`, the default Bay, exactly as before. An unknown name is refused, never guessed.
+    const bay = options.bay ? (0, bays_1.findBayLogin)((0, config_1.loadBayLogins)(), options.bay) : undefined;
+    const token = bay ? bay.token : device.token;
     const joining = Boolean(options.session || options.group || options.destination);
     const runtime = options.runtime ?? (0, owner_pid_1.detectRuntime)(profiles_1.RUNTIME_PROFILES);
     if (joining && !runtime)
@@ -88,7 +95,7 @@ async function cmdJoinSession(args) {
     try {
         await client.connect(new streamableHttp_js_1.StreamableHTTPClientTransport(new URL("/api/mcp", device.baseUrl), {
             requestInit: {
-                headers: { Authorization: `Bearer ${device.token}` },
+                headers: { Authorization: `Bearer ${token}` },
                 signal: AbortSignal.timeout(15_000),
             },
         }));
@@ -155,7 +162,11 @@ async function cmdJoinSession(args) {
                     title?.trim().toLowerCase() !== options.group.trim().toLowerCase())) {
                 throw new Error("The server did not confirm the requested group. Incoming delivery was not attached.");
             }
-            console.log((0, message_format_1.cleanTerminalText)(`Joined as "${name}" in ${isGroup ? `group "${title ?? "Untitled"}"` : "private chat"} (${conversation.id}).`));
+            const joinedBay = structured?.bay && typeof structured.bay === "object" && "name" in structured.bay &&
+                typeof structured.bay.name === "string" && structured.bay.name
+                ? ` in Bay "${structured.bay.name}"`
+                : "";
+            console.log((0, message_format_1.cleanTerminalText)(`Joined as "${name}"${joinedBay} in ${isGroup ? `group "${title ?? "Untitled"}"` : "private chat"} (${conversation.id}).`));
             console.log((0, message_format_1.cleanTerminalText)(`Use session="${name}" and conversationId="${conversation.id}" on chat calls.`));
             // Keep the room's actual rules, not the remote client's transport menu:
             // this command is already responsible for registering incoming delivery.
@@ -181,9 +192,18 @@ async function cmdJoinSession(args) {
     // Installing a service does not prove it started. Confirm its socket answers
     // before claiming that an incoming message has somewhere to go.
     const startup = await (0, commands_1.ensureRelayInstalled)();
+    // A non-default Bay has its own relay, run by the main one (relay/bay-relays.ts); from here
+    // on this process talks to THAT one. It can take up to the supervisor's interval to appear
+    // after a fresh login, so it is given longer than the main relay's one second.
+    const otherBay = bay && !bay.isDefault;
+    if (otherBay)
+        (0, commands_1.useBayRelay)(bay.bayId);
     let status = await (0, commands_1.tryRelayStatus)();
-    for (let attempt = 0; !status && attempt < 10; attempt++) {
-        await new Promise((resolve) => setTimeout(resolve, 100));
+    const attempts = otherBay ? 70 : 10;
+    if (!status && otherBay)
+        console.log(`Waiting for the ${bay.bayName} relay…`);
+    for (let attempt = 0; !status && attempt < attempts; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, otherBay ? 500 : 100));
         status = await (0, commands_1.tryRelayStatus)();
     }
     if (!status) {

package/dist/skill-bootstrap.js

@@ -5,7 +5,7 @@ exports.renderSkillBootstrap = renderSkillBootstrap;
 function renderSkillBootstrap(runtime) {
     const invocation = runtime === "codex" ? "$baychat" : "/baychat";
     const tools = runtime === "claude"
-        ? "allowed-tools:\n  - Bash\n  - Monitor\n  - mcp__baychat\n"
+        ? "allowed-tools:\n  - Bash\n  - Monitor\n  - mcp__baychat\n  - mcp__baychat_channel\n"
         : "";
     return `---
 name: baychat

package/dist/start-command.js

@@ -45,6 +45,7 @@ const terminal_pane_1 = require("./relay/terminal-pane");
 const profiles_1 = require("./relay/profiles");
 const runtime_binary_1 = require("./runtime-binary");
 const update_command_1 = require("./update-command");
+const launch_1 = require("./channel/launch");
 /**
  * `baychat start [name]` — the whole product in one command.
  *
@@ -130,25 +131,32 @@ async function cmdStart(args) {
         console.error(`Could not start ${runtime}: ${binary.reason}`);
         return 1;
     }
+    // THE WAKE-UP CHANNEL (docs/features/CLAUDE_CODE_CHANNEL.md). Claude Code delivers a channel's
+    // events only to a session started with the flag, so this is where it is switched on — when
+    // `connect claude` registered the server and this Claude Code is new enough to take the flag
+    // (an unknown flag would stop it starting). Otherwise it starts exactly as before and the
+    // session listens through a Monitor.
+    const agentArgs = runtime === "claude" ? channelArgs(binary.path) : [];
+    const env = agentArgs.length ? { ...process.env, BAYCHAT_CHANNEL: "1" } : process.env;
     // ALREADY INSIDE ONE? Then just run the agent. Nesting multiplexers sends every prefix
     // key to the wrong one, and the person already has everything this command provides.
     const inside = (0, terminal_pane_1.detectPane)();
     const multiplexer = inside ? undefined : firstAvailable(["tmux", "screen"]);
     if (!multiplexer) {
-        const result = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        const result = (0, child_process_1.spawnSync)(binary.path, agentArgs, { stdio: "inherit", env });
         return result.status ?? 0;
     }
     const sessionName = name || "baychat";
     const argv = multiplexer === "tmux"
         ? // `-A` attaches to an existing session of that name instead of failing, so running
             // this twice returns you to your agent rather than erroring at you.
-            ["new", "-A", "-s", sessionName, binary.path]
-        : ["-S", sessionName, "-R", binary.path];
-    const result = (0, child_process_1.spawnSync)(multiplexer, argv, { stdio: "inherit" });
+            ["new", "-A", "-s", sessionName, binary.path, ...agentArgs]
+        : ["-S", sessionName, "-R", binary.path, ...agentArgs];
+    const result = (0, child_process_1.spawnSync)(multiplexer, argv, { stdio: "inherit", env });
     if (result.error) {
         // Falling back rather than failing: the multiplexer is an enhancement, and refusing to
         // start somebody's agent because of one would be the tail wagging the dog.
-        const direct = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        const direct = (0, child_process_1.spawnSync)(binary.path, agentArgs, { stdio: "inherit", env });
         return direct.status ?? 0;
     }
     return result.status ?? 0;
@@ -233,3 +241,12 @@ function valueAfter(args, flagName) {
     const index = args.indexOf(flagName);
     return index === -1 ? undefined : args[index + 1];
 }
+/** The channel flag for this Claude Code, or nothing when it is not registered or too old. */
+function channelArgs(claudePath) {
+    if (!(0, launch_1.channelRegistered)())
+        return [];
+    const probe = (0, child_process_1.spawnSync)(claudePath, ["--version"], { encoding: "utf8", timeout: 10_000 });
+    if (probe.error || probe.status !== 0)
+        return [];
+    return (0, launch_1.claudeSupportsChannel)((0, launch_1.parseClaudeVersion)(String(probe.stdout ?? ""))) ? [...launch_1.CHANNEL_LAUNCH_ARGS] : [];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.25.3",
+  "version": "0.27.0",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex, Cursor) with BayChat, or have the relay run DeepSeek or the Cursor CLI for you",
   "bin": {
     "baychat": "dist/index.js"