baychat 0.28.0 → 0.29.0

package/dist/channel/plugin.js

@@ -0,0 +1,182 @@
+"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.PLUGIN_MARKETPLACE_NAME = exports.PLUGIN_MARKETPLACE_URL = void 0;
+exports.realPluginFiles = realPluginFiles;
+exports.claudeUserSettingsPath = claudeUserSettingsPath;
+exports.pluginEnabled = pluginEnabled;
+exports.baychatMarketplace = baychatMarketplace;
+exports.installedPlugin = installedPlugin;
+exports.pluginChannelReady = pluginChannelReady;
+exports.installPluginWithClaude = installPluginWithClaude;
+/**
+ * BayChat as a Claude Code plugin: installing it, and reading what Claude Code actually installed.
+ *
+ * The plugin is the `baychat` npm package itself (`.claude-plugin/plugin.json` declares the
+ * channel), listed in a catalog served at baychat.io. `launch.ts` decides how a session is started
+ * with whichever form of the channel is installed; this file owns the plugin form.
+ *
+ * SUCCESS IS READ FROM WHAT IS INSTALLED, NEVER FROM EXIT CODES. `claude plugin marketplace add`
+ * and `claude plugin install` both answer "already" for ANY marketplace or plugin of that name.
+ * Computers set up with BayChat before the channel existed carry a marketplace that is ALSO named
+ * `baychat` — GitHub `SeaQuestdev/baychat-plugins`, whose `baychat` plugin is skill-only (no
+ * `mcpServers`, no `channels`). On those both steps said "already", connect removed the
+ * hand-registered `baychat_channel`, and the channel existed nowhere while setup reported success
+ * (2026-10-03, a laptop upgraded from 0.24.0 to 0.28.0). So the installed plugin's own manifest is
+ * the evidence, here and in `doctor`.
+ *
+ * Every reader takes `PluginFiles`, so the decisions are testable against any machine's files.
+ * Claude Code's file layout is not a published contract: anything unreadable or unexpected reads
+ * as "not installed", which sends the installer to its safe fallback (the hand-registered server).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const detect_1 = require("./detect");
+/** Where `claude plugin marketplace add` finds BayChat's plugin catalog (served by the web app). */
+exports.PLUGIN_MARKETPLACE_URL = "https://baychat.io/claude/marketplace.json";
+/** The catalog's name, the part of `PLUGIN_ID` after the `@`. */
+exports.PLUGIN_MARKETPLACE_NAME = detect_1.PLUGIN_ID.slice(detect_1.PLUGIN_ID.indexOf("@") + 1);
+function realPluginFiles(home = os.homedir()) {
+    return {
+        home,
+        read: (file) => {
+            try {
+                return fs.readFileSync(file, "utf8");
+            }
+            catch {
+                return null; // Absent or unreadable: the readers below turn that into "not installed".
+            }
+        },
+    };
+}
+/** Claude Code's user settings, where installed plugins are switched on. */
+function claudeUserSettingsPath(home = os.homedir()) {
+    return path.join(home, ".claude", "settings.json");
+}
+/** Is BayChat's plugin installed and switched on for this user? Unreadable counts as no. */
+function pluginEnabled(files = realPluginFiles()) {
+    const settings = readJson(files, claudeUserSettingsPath(files.home));
+    return settings?.enabledPlugins?.[detect_1.PLUGIN_ID] === true;
+}
+/** Read from `~/.claude/plugins/known_marketplaces.json`. Unreadable counts as absent. */
+function baychatMarketplace(files) {
+    const known = readJson(files, path.join(pluginsDir(files.home), "known_marketplaces.json"));
+    const source = known?.[exports.PLUGIN_MARKETPLACE_NAME]?.source;
+    if (!source || typeof source !== "object")
+        return { kind: "absent" };
+    if (source.source === "url" && source.url === exports.PLUGIN_MARKETPLACE_URL)
+        return { kind: "ours" };
+    const where = [source.repo, source.url, source.path].find((v) => typeof v === "string");
+    return { kind: "foreign", source: [source.source, where].filter((v) => typeof v === "string").join(" ") || "unknown source" };
+}
+/**
+ * Read `installed_plugins.json` (the user-scope entry; `connect` installs at user scope), then that
+ * install's `.claude-plugin/plugin.json`. Only a manifest with a non-empty `channels` counts.
+ */
+function installedPlugin(files) {
+    const record = readJson(files, path.join(pluginsDir(files.home), "installed_plugins.json"));
+    const entries = record?.plugins?.[detect_1.PLUGIN_ID];
+    // Version 2 of the file keeps a list per plugin (one per scope); version 1 kept one object.
+    const list = (Array.isArray(entries) ? entries : entries ? [entries] : []);
+    const entry = list.find((e) => e?.scope === "user") ?? list.find((e) => e?.scope === undefined);
+    if (!entry || typeof entry.installPath !== "string")
+        return { state: "absent" };
+    const version = typeof entry.version === "string" ? entry.version : "unknown";
+    const manifestPath = path.join(entry.installPath, ".claude-plugin", "plugin.json");
+    const manifest = readJson(files, manifestPath);
+    if (!manifest)
+        return { state: "no-channel", version, why: `its manifest (${manifestPath}) could not be read` };
+    if (!Array.isArray(manifest.channels) || manifest.channels.length === 0) {
+        return { state: "no-channel", version, why: "its manifest declares no channel" };
+    }
+    return { state: "channel", version };
+}
+/** The one condition under which the plugin delivers the channel: switched on, and declaring it. */
+function pluginChannelReady(files) {
+    return pluginEnabled(files) && installedPlugin(files).state === "channel";
+}
+/**
+ * Install BayChat as a Claude Code plugin, and say whether the channel is now there.
+ *
+ * 1. A `baychat` marketplace from anywhere but baychat.io is removed first — otherwise "add"
+ *    answers "already" and the old catalog stays.
+ * 2. Add the catalog from baychat.io and install from it (the plugin is fetched from the `baychat`
+ *    npm package).
+ * 3. Read what is installed. "Already installed" can be a plugin from before — the old skill-only
+ *    one, or one switched off — so a plugin without the channel is reinstalled once.
+ * 4. Only then remove the hand-registered server, which would otherwise hide the plugin's.
+ *
+ * True ONLY when the installed plugin is switched on and declares the channel. False at the first
+ * step that fails, with the hand-registered server untouched — the caller then registers it by
+ * hand, and a session started with both named keeps working either way.
+ */
+function installPluginWithClaude(run, files = realPluginFiles()) {
+    if (baychatMarketplace(files).kind === "foreign") {
+        if (run(["plugin", "marketplace", "remove", exports.PLUGIN_MARKETPLACE_NAME]).status !== 0)
+            return false;
+    }
+    const added = run(["plugin", "marketplace", "add", exports.PLUGIN_MARKETPLACE_URL]);
+    if (added.status !== 0 && !/already/i.test(added.stderr))
+        return false;
+    if (!installFromCatalog(run))
+        return false;
+    if (!pluginChannelReady(files)) {
+        run(["plugin", "uninstall", detect_1.PLUGIN_ID]); // Absent is fine: the install below decides.
+        if (!installFromCatalog(run) || !pluginChannelReady(files))
+            return false;
+    }
+    run(["mcp", "remove", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY]); // Absent is fine.
+    return true;
+}
+function installFromCatalog(run) {
+    const installed = run(["plugin", "install", detect_1.PLUGIN_ID]);
+    return installed.status === 0 || /already installed/i.test(installed.stderr);
+}
+function pluginsDir(home) {
+    return path.join(home, ".claude", "plugins");
+}
+/** Parsed JSON, or undefined when the file is absent, unreadable or not JSON. */
+function readJson(files, file) {
+    const text = files.read(file);
+    if (text === null)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/channel/relay-link.js

@@ -0,0 +1,257 @@
+"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.RelayLink = void 0;
+exports.describeCommandReach = describeCommandReach;
+/**
+ * The channel's link to this computer's relay: how a channel session's `/clear` gets typed.
+ *
+ * ── WHY A CHANNEL SESSION NEEDS THE RELAY AT ALL ──────────────────────────────────────
+ *
+ * The channel delivers messages, but a `<channel>` event is a PROMPT: Claude Code never reads a
+ * slash command out of one. `/clear`, `/new`, `/compact` and the fresh start's clear work only
+ * when something TYPES them into the session's terminal, and the relay is what does that
+ * (relay/terminal-pane.ts). So after `listen` goes active, the channel server registers its
+ * session with the relay — for commands only (relay/channel-sessions.ts): the relay never wakes
+ * it, and drops its chat, because the channel already delivered it.
+ *
+ * ── WHAT IT SENDS, AND WHY IT IS READ HERE ────────────────────────────────────────────
+ *
+ * The pane (`$TMUX`/`$TMUX_PANE`, or screen's `$STY`/`$WINDOW`) and the Claude Code process.
+ * Both are read in THIS process, which Claude Code started and whose environment it inherited —
+ * the same rule `relay attach` follows: the process inside the session answers, the relay never
+ * guesses where to send keystrokes.
+ *
+ * ── WHY THE SOCKET STAYS OPEN ─────────────────────────────────────────────────────────
+ *
+ * Its close tells the relay the session is gone (Claude Code exiting closes this process's
+ * stdin, and the process exits), so a pane a later shell occupies is never typed into on this
+ * registration's word. And it carries the fresh start's note request back (`handoff-note`). A
+ * relay that is not running, or restarts, is retried with backoff for as long as the channel
+ * lives; `onChange` says when the relay starts or stops running this session's commands.
+ */
+const net = __importStar(require("node:net"));
+const socket_1 = require("../relay/socket");
+const channel_sessions_1 = require("../relay/channel-sessions");
+const feed_1 = require("./feed");
+/** How long `start` waits for the first answer before reporting "still connecting". */
+const FIRST_ANSWER_MS = 3_000;
+/** A note request is BayChat's own short instruction; anything longer is not one. */
+const MAX_NOTE_CHARS = 4_000;
+class RelayLink {
+    opts;
+    current = { kind: "connecting" };
+    socket;
+    attempt = 0;
+    retryTimer;
+    settleFirst;
+    setTimer;
+    clearTimer;
+    constructor(opts) {
+        this.opts = opts;
+        this.setTimer =
+            opts.setTimer ??
+                ((fn, ms) => {
+                    const t = setTimeout(fn, ms);
+                    // The stdio transport keeps the process alive; a retry timer must not on its own.
+                    t.unref?.();
+                    return t;
+                });
+        this.clearTimer = opts.clearTimer ?? ((h) => clearTimeout(h));
+    }
+    get state() {
+        return this.current;
+    }
+    get registered() {
+        return this.current.kind === "registered";
+    }
+    /** The `listen` answer's line on whether commands from the Bay reach this session. */
+    describeReach() {
+        return describeCommandReach(this.current, this.opts.pane);
+    }
+    /**
+     * Connect and register, resolving with the first answer (or "connecting" after a short wait,
+     * so a wedged relay never holds up `listen`). Never throws: no relay is an ordinary state.
+     */
+    start(firstAnswerMs = FIRST_ANSWER_MS) {
+        return new Promise((resolve) => {
+            const timer = this.setTimer(() => this.settle(), firstAnswerMs);
+            this.settleFirst = () => {
+                this.settleFirst = undefined;
+                this.clearTimer(timer);
+                resolve(this.current);
+            };
+            this.connect();
+        });
+    }
+    /** Stop for good: the relay sees the socket close and stops running this session's commands. */
+    close() {
+        const was = this.registered;
+        this.current = { kind: "closed" };
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        this.retryTimer = undefined;
+        const socket = this.socket;
+        this.socket = undefined;
+        socket?.destroy();
+        this.settle();
+        if (was)
+            this.opts.onChange?.(false);
+    }
+    settle() {
+        this.settleFirst?.();
+    }
+    connect() {
+        if (this.finished())
+            return;
+        let socket;
+        try {
+            socket = (this.opts.connect ?? ((p) => net.createConnection(p)))(this.opts.socketPath);
+        }
+        catch (err) {
+            this.lost(errText(err));
+            return;
+        }
+        this.socket = socket;
+        const mine = () => this.socket === socket && !this.finished();
+        socket.on("connect", () => {
+            if (!mine())
+                return;
+            const frame = {
+                type: "channel-register",
+                session: this.opts.session,
+                runtime: "claude",
+                ...(this.opts.pane ? { pane: this.opts.pane } : {}),
+                ...(this.opts.ownerPid !== undefined ? { ownerPid: this.opts.ownerPid } : {}),
+            };
+            (0, socket_1.writeFrame)(socket, frame);
+        });
+        socket.on("data", (0, socket_1.createFrameReader)((frame) => {
+            if (!mine())
+                return;
+            this.onFrame(frame);
+        }));
+        // `error` is followed by `close`; the reason is kept for the state the close reports.
+        let failure;
+        socket.on("error", (err) => {
+            failure = describeConnectError(err);
+        });
+        socket.on("close", () => {
+            if (!mine())
+                return;
+            this.socket = undefined;
+            this.lost(failure ?? "the relay closed the connection");
+        });
+    }
+    onFrame(frame) {
+        if (frame.type === "attached" && frame.delivery === "channel") {
+            this.attempt = 0;
+            this.current = { kind: "registered" };
+            this.opts.log?.(`relay runs the commands of session "${this.opts.session}"`);
+            this.settle();
+            this.opts.onChange?.(true);
+            return;
+        }
+        if (frame.type === "handoff-note") {
+            if (typeof frame.handoffId !== "string" || typeof frame.content !== "string" || frame.content.length > MAX_NOTE_CHARS)
+                return;
+            this.opts.onHandoffNote({ conversationId: frame.conversationId, handoffId: frame.handoffId, content: frame.content });
+            return;
+        }
+        if (frame.type === "error") {
+            // A refusal is the relay's considered answer (a relay-run session of that name, or a
+            // newer channel for it): retrying would only fight it.
+            const was = this.registered;
+            this.current = { kind: "refused", reason: frame.message === channel_sessions_1.CHANNEL_REPLACED ? channel_sessions_1.CHANNEL_REPLACED : `the relay refused it: ${frame.message}` };
+            const socket = this.socket;
+            this.socket = undefined;
+            socket?.destroy();
+            this.opts.log?.(`relay link for "${this.opts.session}" ended: ${this.current.reason}`);
+            this.settle();
+            if (was)
+                this.opts.onChange?.(false);
+        }
+    }
+    /** The connection failed or dropped: say so, and try again later. */
+    lost(reason) {
+        if (this.finished())
+            return;
+        const was = this.registered;
+        this.current = { kind: "waiting", reason };
+        this.settle();
+        if (was)
+            this.opts.onChange?.(false);
+        const delay = feed_1.BACKOFF_MS[Math.min(this.attempt, feed_1.BACKOFF_MS.length - 1)];
+        this.attempt++;
+        if (this.retryTimer !== undefined)
+            this.clearTimer(this.retryTimer);
+        this.retryTimer = this.setTimer(() => {
+            this.retryTimer = undefined;
+            this.connect();
+        }, delay);
+    }
+    finished() {
+        return this.current.kind === "closed" || this.current.kind === "refused";
+    }
+}
+exports.RelayLink = RelayLink;
+/**
+ * One line for the session (the `listen` answer) on whether its commands from the Bay work, and
+ * what to do when they do not. `pane` is what this process inherited.
+ */
+function describeCommandReach(state, pane) {
+    if (state.kind === "registered") {
+        if (!pane) {
+            return "Commands from the Bay: /status and /help answer, but /clear, /new and /compact cannot reach this session — it is not inside tmux or screen (start it with `baychat claude` next time).";
+        }
+        return "Commands from the Bay (/clear, /new, /compact, Fresh start): ready — this computer's relay types them into this session's terminal.";
+    }
+    if (state.kind === "connecting")
+        return "Commands from the Bay: still connecting to this computer's relay.";
+    if (state.kind === "closed")
+        return "Commands from the Bay: off.";
+    return `Commands from the Bay (/clear, /new, /compact): not available — ${state.reason}.${state.kind === "waiting" ? " Retrying in the background." : ""}`;
+}
+function describeConnectError(err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ECONNREFUSED")
+        return "no BayChat relay is running on this computer (start it with `baychat relay start`)";
+    if (code === "EACCES" || code === "EPERM")
+        return "this process may not open the relay's socket";
+    return `could not reach the relay (${code ?? err.message})`;
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/channel/server.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelService = exports.nodeFeedConnect = exports.CHANNEL_INSTRUCTIONS = void 0;
+exports.realCommandLink = realCommandLink;
+exports.relaySocketFor = relaySocketFor;
 exports.realLogin = realLogin;
 exports.realCallTool = realCallTool;
 exports.mintTicket = mintTicket;
@@ -61,10 +63,16 @@ const zod_1 = require("zod");
 const api_1 = require("../api");
 const bays_1 = require("../bays");
 const config_1 = require("../config");
+const bay_relays_1 = require("../relay/bay-relays");
+const owner_pid_1 = require("../relay/owner-pid");
+const socket_1 = require("../relay/socket");
+const terminal_pane_1 = require("../relay/terminal-pane");
 const ws_1 = require("../relay/ws");
+const claude_link_1 = require("./claude-link");
 const detect_1 = require("./detect");
 const feed_1 = require("./feed");
 const permission_1 = require("./permission");
+const relay_link_1 = require("./relay-link");
 /** Delivered to Claude as context when this server connects. */
 exports.CHANNEL_INSTRUCTIONS = `This is BayChat's wake-up channel. After join_session, call this server's listen tool with the ` +
     `confirmed session name (and bay, when the session joined a Bay other than the default). If it ` +
@@ -73,9 +81,11 @@ exports.CHANNEL_INSTRUCTIONS = `This is BayChat's wake-up channel. After join_se
     `get_messages tool (the same Bay's tools the session joined with), obey shouldRespond and answer ` +
     `in BayChat. Do NOT also open a Monitor or call listen_messages: that would replace this feed. ` +
     `If listen answers inactive or failed, use listen_messages and a native Monitor as before. ` +
-    `event="reset" means catch up with get_messages; event="stopped" means the feed ended and says why. ` +
+    `event="reset" means catch up with get_messages; event="stopped" means the feed ended and says why; ` +
+    `event="handoff" is BayChat's own request for a handoff note before a fresh start: do what it says. ` +
     `Tool-permission prompts are also offered to the session's owner as a BayChat card; answer in the terminal or ` +
-    `on the phone, whichever is first.`;
+    `on the phone, whichever is first. Answer in BayChat only; in the terminal write at most one short line, ` +
+    `never the answer again (both are paid output).`;
 const LISTEN_TOOL = {
     name: "listen",
     description: "Hear this BayChat session's incoming messages through the Claude Code channel instead of a Monitor. " +
@@ -94,6 +104,21 @@ const LISTEN_TOOL = {
         required: ["session"],
     },
 };
+/**
+ * The real command link: the relay socket of the session's Bay, and the pane and Claude Code
+ * process THIS process inherited — Claude Code starts the channel server, so its `$TMUX` and its
+ * parent are the session's (owner-pid.ts walks the live process tree to prove the latter).
+ */
+function realCommandLink(log) {
+    return (session, bay, hooks) => new relay_link_1.RelayLink({ socketPath: relaySocketFor(bay), session, pane: (0, terminal_pane_1.detectPane)(), ownerPid: (0, owner_pid_1.currentOwnerPid)("claude"), ...hooks, log });
+}
+/** The relay that serves a Bay's sessions: the default relay, or that Bay's own (relay/bay-relays.ts). */
+function relaySocketFor(bay) {
+    if (bay === undefined || !bay.trim())
+        return (0, socket_1.socketPath)();
+    const login = (0, bays_1.findBayLogin)((0, config_1.loadBayLogins)(), bay);
+    return login.isDefault ? (0, socket_1.socketPath)() : (0, bay_relays_1.bayRelayScope)(login.bayId, (0, config_1.configDir)(), (0, socket_1.socketPath)()).socket;
+}
 /** The real login lookup: the default Bay, or a named one from `credentials.json`. */
 function realLogin(bay) {
     const device = (0, config_1.loadDeviceCredentials)();
@@ -156,7 +181,7 @@ function httpStatus(err) {
  * session is gone, or the login was refused or ran out. Everything else (offline, a restart,
  * the per-minute limit) is retried by the feed.
  */
-async function mintTicket(deps, bay, session, cursor) {
+async function mintTicket(deps, { bay, session, cursor, commands }) {
     let login;
     try {
         login = deps.login(bay);
@@ -169,7 +194,7 @@ async function mintTicket(deps, bay, session, cursor) {
         return { ok: false, fatal: true, detail: "This computer's BayChat login has expired. Run `baychat login`." };
     }
     try {
-        const result = await deps.callTool(login, "listen_messages", { session, ...(cursor ? { cursor } : {}) });
+        const result = await deps.callTool(login, "listen_messages", { session, ...(cursor ? { cursor } : {}), ...(commands ? { commands } : {}) });
         const text = resultText(result);
         if (result.isError) {
             const fatal = /no live session|SESSION_NOT_FOUND|not a member|cannot delegate/i.test(text);
@@ -206,6 +231,7 @@ class ChannelService {
     deps;
     push;
     feeds = new Map();
+    links = new Map();
     /** The most recent session that listened successfully: where permission prompts go. */
     last;
     constructor(deps, push) {
@@ -233,10 +259,23 @@ class ChannelService {
         }
         const key = `${bayName ?? ""}\u0000${session}`;
         this.feeds.get(key)?.stop();
-        const feed = new feed_1.ChannelFeed({
+        // COMMANDS FIRST, so the first ticket already says whether this computer's relay runs them.
+        // When that changes (the relay starts, stops or restarts), the feed is reopened so the
+        // server's view follows (realtime/remote-listeners.ts). Never a reason to fail `listen`.
+        let feed;
+        const link = this.openCommandLink(key, session, bay, bayName, (registered) => feed?.reopen(registered ? "now has this computer's relay running its commands" : "lost this computer's relay"));
+        if (link)
+            await link.start();
+        feed = new feed_1.ChannelFeed({
             session,
             ...(bayName ? { bayName } : {}),
-            mint: (cursor) => mintTicket(this.deps, bay, session, cursor),
+            mint: (cursor) => mintTicket(this.deps, { bay, session, cursor, ...(link?.registered ? { commands: "relay" } : {}) }),
+            onStop: () => {
+                this.closeCommandLink(key, link);
+                // A stopped feed: the hook must not keep sending cards in a name that may be gone.
+                if (bay === undefined)
+                    this.deps.claudeLink?.remove(session);
+            },
             connect: this.deps.connect,
             status: async () => {
                 try {
@@ -258,15 +297,55 @@ class ChannelService {
         const started = await feed.start();
         if (!started.ok) {
             this.feeds.delete(key);
+            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.last = { key, session, bay };
+        // Approvals for `baychat claude` / `baychat start` (approve-hook --session-from-claude): this
+        // Claude Code is now this session. Only for the default Bay, the one the hook's device login
+        // asks; a session on another Bay keeps its prompts in the terminal (and clears an older link,
+        // so a card never goes out in a name this Claude Code has moved on from).
+        if (bay === undefined)
+            this.deps.claudeLink?.write(session);
+        else
+            this.deps.claudeLink?.remove(undefined);
         return toolResult("active", `Active: session "${session}"${bayName ? ` (${bayName})` : ""} now hears the Bay through the channel. New messages ` +
             `arrive here as <channel event="messages"> events, with no deadline and no re-arming. Do NOT open a ` +
             `Monitor or call listen_messages — either would replace this feed. Now read one get_messages batch (limit 10) ` +
-            `to catch up on anything from before listening.`, { session, ...(bayName ? { bay: bayName } : {}), how: evidence.how });
+            `to catch up on anything from before listening.` +
+            (link ? ` ${link.describeReach()}` : ""), { session, ...(bayName ? { bay: bayName } : {}), how: evidence.how, commands: link?.state.kind ?? "off" });
+    }
+    /**
+     * Register this session's commands with the relay (relay-link.ts). A fresh start's note
+     * request comes back over it and is handed to the session as an event — the relay drops a
+     * channel session's chat, so this is the one way to ask its agent for the note.
+     */
+    openCommandLink(key, session, bay, bayName, onChange) {
+        this.links.get(key)?.close();
+        this.links.delete(key);
+        if (!this.deps.commandLink)
+            return undefined;
+        let link;
+        try {
+            link = this.deps.commandLink(session, bay, {
+                onHandoffNote: (note) => void this.push(note.content, { session, ...(bayName ? { bay: bayName } : {}), event: "handoff", handoff_id: note.handoffId }),
+                onChange,
+            });
+        }
+        catch (err) {
+            // The feed matters more than the commands: a session that cannot be commanded still hears.
+            this.deps.log(`commands from the Bay are off for ${session}: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+        this.links.set(key, link);
+        return link;
+    }
+    closeCommandLink(key, link) {
+        link?.close();
+        if (link && this.links.get(key) === link)
+            this.links.delete(key);
     }
     /**
      * Where a permission prompt goes: the session that most recently started listening, while its
@@ -291,7 +370,11 @@ class ChannelService {
         for (const feed of this.feeds.values())
             feed.stop();
         this.feeds.clear();
+        for (const link of this.links.values())
+            link.close();
+        this.links.clear();
         this.last = undefined;
+        this.deps.claudeLink?.remove(undefined);
     }
 }
 exports.ChannelService = ChannelService;
@@ -325,6 +408,8 @@ async function startChannelServer(deps) {
         callTool: deps?.callTool ?? realCallTool,
         connect: deps?.connect ?? exports.nodeFeedConnect,
         log,
+        commandLink: deps?.commandLink ?? realCommandLink(log),
+        claudeLink: deps?.claudeLink ?? (0, claude_link_1.realClaudeLink)(log),
     }, async (content, meta) => {
         try {
             await mcp.notification({ method: "notifications/claude/channel", params: { content, meta } });