baychat 0.28.0 → 0.29.0

package/dist/relay/launcher/loop.js

@@ -0,0 +1,231 @@
+"use strict";
+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.deviceRequest = void 0;
+exports.startLauncher = startLauncher;
+const fs = __importStar(require("fs"));
+const api_1 = require("../../api");
+const launch_1 = require("../../channel/launch");
+const claude_trust_1 = require("../../launch/claude-trust");
+const policy_1 = require("../../launch/policy");
+const runtime_binary_1 = require("../../runtime-binary");
+const spawn_env_1 = require("../spawn-env");
+const approval_settings_1 = require("./approval-settings");
+const capabilities_1 = require("./capabilities");
+const handle_1 = require("./handle");
+const multiplexer_1 = require("./multiplexer");
+/**
+ * The launcher: this computer's side of "Start a session from BayChat".
+ *
+ * It tells BayChat what it can start (`PUT /launch-capabilities`, again whenever the policy file
+ * changes and every few minutes in case a runtime was installed), then holds
+ * `GET /launches/next?wait=25` — which doubles as the "this computer is online" heartbeat — and
+ * carries out each launch, ONE AT A TIME: the next poll is not made until the previous launch has
+ * been handled and its report delivered, so two launches can never race past the caps.
+ *
+ * Network trouble is never fatal: every failure is logged and retried with a growing pause, and
+ * only `signal` ends the loop. Self-contained so the daemon wires it with one call.
+ */
+const WAIT_SECONDS = 25;
+const BACKOFF_MIN_MS = 1_000;
+const BACKOFF_MAX_MS = 60_000;
+/** Re-advertise this often even when the policy has not changed (a runtime may have been installed). */
+const CAPABILITIES_REFRESH_MS = 10 * 60_000;
+/** A long-poll holds for WAIT_SECONDS; give the request this much beyond it before calling it dead. */
+const REQUEST_GRACE_MS = 15_000;
+async function startLauncher({ auth, log, signal, deps: overrides }) {
+    const deps = { ...realLoopDeps(log, signal), ...overrides };
+    let advertised;
+    let unreported;
+    let backoff = BACKOFF_MIN_MS;
+    while (!signal.aborted) {
+        try {
+            if (unreported) {
+                await deps.request(auth, "POST", `/api/device-api/launches/${encodeURIComponent(unreported.id)}/report`, unreported.report, signal);
+                unreported = undefined;
+            }
+            const stamp = deps.policyStamp();
+            if (!advertised || advertised.stamp !== stamp || deps.now() - advertised.at >= CAPABILITIES_REFRESH_MS) {
+                await deps.request(auth, "PUT", "/api/device-api/launch-capabilities", deps.capabilities(), signal);
+                advertised = { stamp, at: deps.now() };
+            }
+            const answer = (await deps.request(auth, "GET", `/api/device-api/launches/next?wait=${WAIT_SECONDS}`, undefined, signal));
+            const raw = answer?.launch;
+            if (raw) {
+                const launch = (0, handle_1.parseLaunch)(raw);
+                const id = launch?.id ?? idOf(raw);
+                if (!id) {
+                    log("launcher: ignored a launch with no id");
+                }
+                else {
+                    // Kept until delivered: a report lost to the network is sent before the next poll.
+                    const io = launchIo(deps, auth, id, signal);
+                    unreported = { id, report: launch ? await safeHandle(deps, launch, io, log) : { status: "REFUSED", reason: "BAD_REQUEST" } };
+                    await deps.request(auth, "POST", `/api/device-api/launches/${encodeURIComponent(id)}/report`, unreported.report, signal);
+                    unreported = undefined;
+                }
+            }
+            backoff = BACKOFF_MIN_MS;
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            log(`launcher: ${describe(err)}; retrying in ${Math.round(backoff / 1000)}s`);
+            await deps.sleep(backoff, signal);
+            backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+        }
+    }
+}
+/** A bug in handling one launch must report FAILED, not spin the loop on the same launch. */
+async function safeHandle(deps, launch, io, log) {
+    try {
+        return await deps.handle(launch, io);
+    }
+    catch (err) {
+        log(`launch ${launch.id}: ${describe(err)}`);
+        return { status: "FAILED", reason: "LAUNCHER_ERROR" };
+    }
+}
+/** The interim report and the confirm long-poll for launch `id`, over the device API. */
+function launchIo(deps, auth, id, signal) {
+    const base = `/api/device-api/launches/${encodeURIComponent(id)}`;
+    return {
+        report: async (report) => {
+            await deps.request(auth, "POST", `${base}/report`, report, signal);
+        },
+        pollDecision: async () => parseConfirm(await deps.request(auth, "GET", `${base}/confirm?wait=${WAIT_SECONDS}`, undefined, signal)),
+        signal,
+    };
+}
+/** Only an explicit "allow" allows; anything odd reads as "no decision yet". */
+function parseConfirm(raw) {
+    const answer = (raw ?? {});
+    const decision = answer.decision === "allow" || answer.decision === "deny" ? answer.decision : null;
+    return { decision, reason: typeof answer.reason === "string" ? answer.reason : null };
+}
+function idOf(raw) {
+    const id = raw.id;
+    return typeof id === "string" ? id : undefined;
+}
+function describe(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function realLoopDeps(log, signal) {
+    const binaryEnv = () => (0, runtime_binary_1.currentBinaryEnv)();
+    const handleDeps = () => ({
+        loadPolicy: () => (0, policy_1.loadLaunchPolicy)(),
+        resolveFolder: policy_1.resolveSpotFolder,
+        isFolderTrusted: (folder) => (0, claude_trust_1.isFolderTrusted)(folder),
+        resolveBinary: (name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, binaryEnv()),
+        channelLaunch: (claudePath) => {
+            const launch = (0, launch_1.channelLaunchFor)(claudePath);
+            return { args: launch.args, env: launch.env };
+        },
+        detectMultiplexer: () => (0, multiplexer_1.detectMultiplexer)(multiplexer_1.realRun),
+        run: multiplexer_1.realRun,
+        capture: (multiplexer, name) => (0, multiplexer_1.capturePane)(multiplexer, name, multiplexer_1.realRun, { dir: (0, approval_settings_1.launchDir)() }),
+        pressEnter: (multiplexer, name) => (0, multiplexer_1.pressEnter)(multiplexer, name, multiplexer_1.realRun),
+        sleep: (ms) => sleepUnlessAborted(ms, signal),
+        cli: (0, approval_settings_1.currentCliLaunch)(),
+        launchDir: (0, approval_settings_1.launchDir)(),
+        pathEnv: (0, spawn_env_1.headlessSpawnEnv)().PATH ?? "",
+        now: () => new Date(),
+        log,
+    });
+    return {
+        request: exports.deviceRequest,
+        policyStamp: () => {
+            try {
+                const st = fs.statSync((0, policy_1.launchPolicyPath)());
+                return `${st.mtimeMs}:${st.size}`;
+            }
+            catch {
+                return "absent";
+            }
+        },
+        capabilities: () => (0, capabilities_1.buildCapabilities)((0, policy_1.loadLaunchPolicy)(), {
+            resolveBinary: (name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, binaryEnv()),
+            multiplexer: (0, multiplexer_1.detectMultiplexer)(multiplexer_1.realRun),
+        }),
+        handle: (launch, io) => (0, handle_1.handleLaunch)(launch, handleDeps(), io),
+        sleep: sleepUnlessAborted,
+        now: () => Date.now(),
+    };
+}
+/**
+ * The device API, with an abort signal and a deadline. Unlike `apiRequest` it accepts the empty
+ * `204` the capabilities PUT and the report answer with.
+ */
+const deviceRequest = async (auth, method, apiPath, body, signal) => {
+    const res = await fetch(`${auth.baseUrl}${apiPath}`, {
+        method,
+        headers: { Authorization: `Bearer ${auth.token}`, "Content-Type": "application/json" },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.any([signal, AbortSignal.timeout(WAIT_SECONDS * 1000 + REQUEST_GRACE_MS)]),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        let code;
+        try {
+            code = JSON.parse(text).code;
+        }
+        catch {
+            // Not JSON: the status alone says enough, and a response body is never echoed into logs.
+        }
+        throw new api_1.ApiError(res.status, `${method} ${apiPath.split("?")[0]} answered HTTP ${res.status}${code ? ` ${code}` : ""}`, code);
+    }
+    if (!text)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new api_1.ApiError(res.status, `${method} ${apiPath.split("?")[0]} answered with something that is not JSON`);
+    }
+};
+exports.deviceRequest = deviceRequest;
+function sleepUnlessAborted(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", done);
+            resolve();
+        }
+        signal.addEventListener("abort", done, { once: true });
+    });
+}

package/dist/relay/launcher/multiplexer.js

@@ -0,0 +1,168 @@
+"use strict";
+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.realRun = exports.WITHHELD_FROM_AGENTS = void 0;
+exports.agentSafeEnv = agentSafeEnv;
+exports.detectMultiplexer = detectMultiplexer;
+exports.liveLaunchSessions = liveLaunchSessions;
+exports.killLaunchSession = killLaunchSession;
+exports.tmuxPaneTarget = tmuxPaneTarget;
+exports.capturePane = capturePane;
+exports.pressEnter = pressEnter;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const argv_1 = require("./argv");
+const RUN_TIMEOUT_MS = 10_000;
+/**
+ * Variables the relay may hold that must never reach a launched agent. A tmux or screen server the
+ * launcher starts inherits this process's environment, and every pane in it inherits the server's:
+ * the device token is this computer's login, and an agent (or anything it runs) must not be able to
+ * read it from its own environment. Found in the 2026-10-05 live run, where a test relay's
+ * BAYCHAT_DEVICE_TOKEN showed up in the launched session's channel process.
+ */
+exports.WITHHELD_FROM_AGENTS = ["BAYCHAT_DEVICE_TOKEN", "BAYCHAT_TOKEN"];
+function agentSafeEnv(env) {
+    const out = { ...env };
+    for (const key of exports.WITHHELD_FROM_AGENTS)
+        delete out[key];
+    return out;
+}
+const realRun = (file, args, opts) => {
+    const res = (0, child_process_1.spawnSync)(file, args, {
+        shell: false,
+        encoding: "utf8",
+        timeout: RUN_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "pipe"],
+        cwd: opts?.cwd,
+        env: agentSafeEnv(opts?.env ? { ...process.env, ...opts.env } : process.env),
+    });
+    return { status: res.status, stdout: String(res.stdout ?? ""), stderr: String(res.stderr ?? ""), error: res.error };
+};
+exports.realRun = realRun;
+/**
+ * The multiplexer a launch would use: tmux, else screen, else null.
+ *
+ * Probed by RUNNING it, as `baychat start` does. screen is matched on its banner, not its exit
+ * status: GNU screen 4.00 prints "Screen version …" for `-v` and exits 1 (measured on macOS).
+ */
+function detectMultiplexer(run) {
+    const tmux = run("tmux", ["-V"]);
+    if (!tmux.error && tmux.status === 0)
+        return "tmux";
+    const screen = run("screen", ["-v"]);
+    if (!screen.error && /screen version/i.test(`${screen.stdout}${screen.stderr}`))
+        return "screen";
+    return null;
+}
+/**
+ * The session names (without `bc-`) of every launcher-made session alive in `multiplexer`.
+ * No server running means none.
+ */
+function liveLaunchSessions(multiplexer, run) {
+    if (multiplexer === "tmux") {
+        const res = run("tmux", ["ls", "-F", "#{session_name}"]);
+        if (res.error || res.status !== 0)
+            return [];
+        return withoutPrefix(res.stdout.split("\n").map((l) => l.trim()));
+    }
+    // `screen -ls` lines look like "\t12345.bc-name\t(Detached)"; it exits 1 even when listing.
+    const res = run("screen", ["-ls"]);
+    if (res.error)
+        return [];
+    const names = res.stdout.split("\n").map((l) => /^\s*\d+\.(\S+)\s/.exec(l)?.[1] ?? "");
+    return withoutPrefix(names);
+}
+/** Kill the launcher session for `sessionName`. True when the multiplexer said it did. */
+function killLaunchSession(multiplexer, sessionName, run) {
+    const target = (0, argv_1.multiplexerSessionName)(sessionName);
+    const res = multiplexer === "tmux"
+        ? run("tmux", ["kill-session", "-t", `=${target}`]) // `=`: exact name, never a prefix match
+        : run("screen", ["-S", target, "-X", "quit"]);
+    return !res.error && res.status === 0;
+}
+/**
+ * The tmux target for the launcher's pane of `sessionName`. Pane commands (capture-pane,
+ * send-keys) need the trailing colon: tmux 3.7c answers "can't find pane: =bc-x" for the bare
+ * form, while `=bc-x:` resolves that session's active pane, and `=` refuses a prefix match
+ * (`=bc-x:` never reaches `bc-x2`). Verified on macOS with a throwaway session, 2026-10-05.
+ */
+function tmuxPaneTarget(sessionName) {
+    return `=${(0, argv_1.multiplexerSessionName)(sessionName)}:`;
+}
+const realHardcopyFs = {
+    readFile: (file) => fs.readFileSync(file, "utf8"),
+    remove: (file) => fs.rmSync(file, { force: true }),
+};
+/**
+ * What the launcher's pane shows right now, as text; null when it cannot be read (the session is
+ * gone, the multiplexer failed). Read-only.
+ */
+function capturePane(multiplexer, sessionName, run, opts) {
+    if (multiplexer === "tmux") {
+        // -J joins wrapped lines, so a phrase is never split across two lines by a narrow pane.
+        const res = run("tmux", ["capture-pane", "-p", "-J", "-t", tmuxPaneTarget(sessionName)]);
+        return res.error || res.status !== 0 ? null : res.stdout;
+    }
+    const files = opts.fs ?? realHardcopyFs;
+    const file = path.join(opts.dir, `${sessionName}.hardcopy.txt`);
+    const res = run("screen", ["-S", (0, argv_1.multiplexerSessionName)(sessionName), "-p", "0", "-X", "hardcopy", file]);
+    if (res.error || res.status !== 0)
+        return null;
+    try {
+        return files.readFile(file);
+    }
+    catch {
+        return null;
+    }
+    finally {
+        try {
+            files.remove(file);
+        }
+        catch {
+            // A leftover hardcopy holds only what the pane showed; it is overwritten next time.
+        }
+    }
+}
+/** Send ONE Enter to the launcher's pane. True when the multiplexer accepted it. */
+function pressEnter(multiplexer, sessionName, run) {
+    const res = multiplexer === "tmux"
+        ? run("tmux", ["send-keys", "-t", tmuxPaneTarget(sessionName), "Enter"])
+        : run("screen", ["-S", (0, argv_1.multiplexerSessionName)(sessionName), "-X", "stuff", "\r"]);
+    return !res.error && res.status === 0;
+}
+function withoutPrefix(names) {
+    return names.filter((n) => n.startsWith(argv_1.LAUNCH_SESSION_PREFIX) && n.length > argv_1.LAUNCH_SESSION_PREFIX.length).map((n) => n.slice(argv_1.LAUNCH_SESSION_PREFIX.length));
+}

package/dist/relay/launcher/started.js

@@ -0,0 +1,63 @@
+"use strict";
+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.startedRecordPath = startedRecordPath;
+exports.loadStarted = loadStarted;
+exports.saveStarted = saveStarted;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const approval_settings_1 = require("./approval-settings");
+function startedRecordPath(dir = (0, approval_settings_1.launchDir)()) {
+    return path.join(dir, "started.json");
+}
+/** The recorded sessions; [] when the file is missing or unreadable (nothing may be stopped). */
+function loadStarted(file = startedRecordPath()) {
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const sessions = raw?.sessions;
+    if (!Array.isArray(sessions))
+        return [];
+    return sessions.filter((s) => !!s && typeof s === "object" && typeof s.name === "string" && typeof s.spotId === "string" && (s.multiplexer === "tmux" || s.multiplexer === "screen"));
+}
+function saveStarted(sessions, file = startedRecordPath()) {
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(file, `${JSON.stringify({ sessions }, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(file, 0o600);
+}

package/dist/relay/profiles.js

@@ -191,7 +191,7 @@ exports.RUNTIME_PROFILES = [
         noHeadlessReason: "DeepSeek Harness is run by the relay over ACP (`baychat connect dsh`), which enforces modes; a terminal dsh session is not woken headlessly.",
         confidence: "docs",
         checked: "2026-09-19",
-        source: "https://www.npmjs.com/package/@deepseek-ai/dsh (0.1.5-rc.2, dsh-shell-env + dsh-acp README)",
+        source: "https://www.npmjs.com/package/@deepseek-ai/dsh (0.1.5-rc.2, dsh-shell-env + dsh-acp README; MCP entry and skills folder unchanged in 0.2.0-rc.2 source, 2026-10-01)",
     },
     {
         id: "pi",

package/dist/relay/registry.js

@@ -110,6 +110,32 @@ class SessionRegistry {
         this.save();
         return merged;
     }
+    /**
+     * Record a target WHOLE, replacing what was known — for a registration that describes the
+     * session completely (a Claude Code channel's). `upsert` would keep an old `pane` the new
+     * registration left out, and that pane may now hold a shell.
+     */
+    replace(target) {
+        const fresh = { ...stripUndefined(target), name: target.name, runtime: target.runtime, registeredAt: new Date().toISOString() };
+        this.sessions.set(target.name, fresh);
+        this.save();
+        return fresh;
+    }
+    /**
+     * Hand delivery back to the relay's wake ladder (or to another owner): an attach taking over
+     * a name a channel registered must not inherit "the channel delivers, drop the chat". A
+     * separate method because `upsert` strips undefined, as `clearResume` explains.
+     */
+    setDelivery(name, delivery) {
+        const existing = this.sessions.get(name);
+        if (!existing || existing.delivery === delivery)
+            return;
+        if (delivery === undefined)
+            delete existing.delivery;
+        else
+            existing.delivery = delivery;
+        this.save();
+    }
     get(name) {
         return this.sessions.get(name);
     }

package/dist/relay/terminal-pane.js

@@ -81,7 +81,7 @@ function verifyPane(handle, runtime, run = (file, args) => (0, child_process_1.e
             "-p",
             "-t",
             handle.pane,
-            "#{pane_dead} #{pane_current_command}",
+            "#{pane_dead} #{pane_current_command} #{pane_tty}",
         ]).trim();
     }
     catch (err) {
@@ -90,10 +90,17 @@ function verifyPane(handle, runtime, run = (file, args) => (0, child_process_1.e
             reason: `tmux could not find pane ${handle.pane} any more (${errText(err)}).`,
         };
     }
-    const [dead, current] = out.split(/\s+/);
+    const [dead, current, paneTty] = out.split(/\s+/);
     if (dead !== "0")
         return { ok: false, reason: `pane ${handle.pane} has exited.` };
     const want = expectedCommand(runtime);
+    // A launcher that stayed the pane's foreground program: `baychat claude` or `baychat start`
+    // run INSIDE tmux keeps `node` as the parent of the agent (Node cannot exec), so tmux names
+    // `node`. Typing is still safe when the session's OWN recorded process is alive, is the
+    // runtime, and sits in that pane's foreground process group — what a keystroke reaches.
+    // When the agent has exited (a shell left on the pane) that process is gone: still refused.
+    if (current !== want && ownerPid !== undefined && ownerHoldsPane(ownerPid, runtime, paneTty, run))
+        return { ok: true };
     if (current !== want) {
         return {
             ok: false,
@@ -102,6 +109,28 @@ function verifyPane(handle, runtime, run = (file, args) => (0, child_process_1.e
     }
     return { ok: true };
 }
+/**
+ * Is the session's recorded runtime process the FOREGROUND of the pane's terminal?
+ *
+ * Three facts, all from the OS: the process is alive and is the runtime (`runtimeStillRunning`);
+ * its controlling terminal is the pane's (`pane_tty`); and its process group is that terminal's
+ * foreground group (`pgid == tpgid`), so keystrokes reach it and not a shell or a subprocess. A
+ * reused pid on another terminal fails the second; an agent in the background fails the third.
+ */
+function ownerHoldsPane(pid, runtime, paneTty, run) {
+    if (!paneTty || !runtimeStillRunning(pid, runtime, run).ok)
+        return false;
+    let out;
+    try {
+        out = run("ps", ["-o", "tpgid=,pgid=,tty=", "-p", String(pid)]).trim();
+    }
+    catch {
+        return false;
+    }
+    const [tpgid, pgid, tty] = out.split(/\s+/);
+    const bare = (t) => t.replace(/^\/dev\//, "");
+    return !!tty && tty !== "?" && bare(tty) === bare(paneTty) && !!pgid && Number(pgid) > 0 && tpgid === pgid;
+}
 /**
  * Is `pid` still running, and still the runtime we recorded?
  *

package/dist/relay/transport.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SeenDeliveries = void 0;
+exports.SeenDeliveries = exports.NO_WEBSOCKET_DETAIL = void 0;
 exports.runRelayFeed = runRelayFeed;
 /**
  * The relay's event SOURCE, and the only place that chooses between the two.
@@ -44,6 +44,11 @@ const HEALTHY_AFTER_MS = 60_000;
 const WS_RETRY_LADDER_MS = [3_000, 15_000, 60_000, 300_000, 600_000];
 /** How often the live-session list is re-read while the socket is up. See `refreshSessions`. */
 const SESSION_REFRESH_MS = 60_000;
+/**
+ * `relay status`'s transport detail when this Node has no WebSocket at all. A wire value across the
+ * process boundary: `doctor` matches it to say the relay's Node is too old, not the server.
+ */
+exports.NO_WEBSOCKET_DETAIL = "fallback — no WebSocket in this runtime";
 /** Deliveries (session + message id) remembered for de-duplication across a transport switch. */
 const SEEN_DELIVERIES_LIMIT = 2_000;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -150,7 +155,7 @@ async function runRelayFeed(opts) {
         // straight out of here, exactly as it did before.
         const detail = socketsPossible
             ? `fallback — retrying the socket in ${Math.max(0, Math.round((retryAfter - Date.now()) / 1000))}s`
-            : "fallback — no WebSocket in this runtime";
+            : exports.NO_WEBSOCKET_DETAIL;
         announce("long-poll", detail);
         const stint = new AbortController();
         const stopStint = () => stint.abort();

package/dist/relay/ws.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nodeWebSocketConnect = exports.WebSocketUnavailableError = exports.AGENT_WS_PATH = void 0;
+exports.nodeWebSocketConnect = exports.WebSocketUnavailableError = exports.NODE_UPGRADE_HINT = exports.WEBSOCKET_MIN_NODE = exports.AGENT_WS_PATH = void 0;
+exports.hasBuiltInWebSocket = hasBuiltInWebSocket;
 exports.runWebSocketFeed = runWebSocketFeed;
 exports.wsUrlFor = wsUrlFor;
 exports.parseFrame = parseFrame;
@@ -31,6 +32,22 @@ exports.AGENT_WS_PATH = "/api/agent-api/ws";
 const READY_TIMEOUT_MS = 10_000;
 /** Close code the gateway uses when the credential stopped verifying. */
 const WS_CLOSE_CREDENTIAL = 4001;
+/** The first Node with a built-in `WebSocket`: what the relay's socket and the Claude Code channel need. */
+exports.WEBSOCKET_MIN_NODE = 22;
+/**
+ * Does this Node have the built-in `WebSocket`? Node 20 has none, and `engines` still allows it —
+ * there the relay long-polls (and the server throttles it) and `baychat channel` cannot start.
+ */
+function hasBuiltInWebSocket() {
+    return typeof globalThis.WebSocket === "function";
+}
+/**
+ * What to do on a Node without it, as `doctor` and `connect claude` say it. Reinstalling under the
+ * new Node matters: npm keeps one global `baychat` per Node, and `baychat update` rewrites the
+ * relay's service with the Node it runs on.
+ */
+exports.NODE_UPGRADE_HINT = `run baychat on Node ${exports.WEBSOCKET_MIN_NODE} or newer: install it, \`npm install -g baychat\` with it, then \`baychat update\`` +
+    " (docs/features/CLAUDE_CODE_CHANNEL.md has a recipe that leaves the system Node alone)";
 /** Thrown by `nodeWebSocketConnect` on a runtime with no global `WebSocket`. */
 class WebSocketUnavailableError extends Error {
     constructor(message) {

package/dist/runtime-install.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installRuntimeCommand = installRuntimeCommand;
+exports.skillFileBody = skillFileBody;
 exports.describeInstall = describeInstall;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -70,9 +71,7 @@ function installRuntimeCommand(runtime, home = os.homedir()) {
     }
     const dir = path.join(home, spec.command.dir);
     const file = path.join(dir, spec.command.file);
-    const body = runtime === "codex" || runtime === "claude"
-        ? (0, skill_bootstrap_1.renderSkillBootstrap)(runtime)
-        : spec.command.render((0, runtimes_1.commandContextFor)(runtime));
+    const body = skillFileBody(runtime);
     fs.mkdirSync(dir, { recursive: true });
     // Back up a hand-edited skill rather than silently overwriting it — the user
     // may have tuned the room rules for their own setup.
@@ -82,6 +81,23 @@ function installRuntimeCommand(runtime, home = os.homedir()) {
     fs.writeFileSync(file, body, { mode: 0o644 });
     return { ...base, written: file };
 }
+/**
+ * Exactly what `installRuntimeCommand` writes for a runtime, or null when it writes nothing.
+ *
+ * ONE function, because `doctor` compares the installed file against it. Claude Code and Codex
+ * get a small, stable bootstrap that loads the current workflow from the package at run time
+ * (`baychat skill --runtime …`); the others get the whole workflow. When doctor compared against
+ * the whole workflow instead, every freshly updated Claude Code / Codex machine was reported
+ * "out of date" — a check that fails on a correct install (2026-10-03).
+ */
+function skillFileBody(runtime) {
+    const spec = (0, runtimes_1.runtimeSpec)(runtime);
+    if (!spec.command)
+        return null;
+    return runtime === "codex" || runtime === "claude"
+        ? (0, skill_bootstrap_1.renderSkillBootstrap)(runtime)
+        : spec.command.render((0, runtimes_1.commandContextFor)(runtime));
+}
 /** Human-readable summary lines for the end of `connect`. */
 function describeInstall(report) {
     const spec = (0, runtimes_1.runtimeSpec)(report.runtime);