baychat 0.28.0 → 0.29.0

package/.claude-plugin/plugin.json

@@ -1,12 +1,32 @@
 {
   "name": "baychat",
+  "version": "0.29.0",
   "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": { "name": "BayChat", "url": "https://baychat.io" },
+  "author": {
+    "name": "BayChat",
+    "url": "https://baychat.io"
+  },
   "homepage": "https://baychat.io",
-  "keywords": ["baychat", "chat", "channel", "mobile", "notifications"],
+  "keywords": [
+    "baychat",
+    "chat",
+    "channel",
+    "mobile",
+    "notifications"
+  ],
   "mcpServers": {
-    "channel": { "command": "baychat", "args": ["channel"] }
+    "channel": {
+      "command": "baychat",
+      "args": [
+        "channel"
+      ]
+    }
   },
-  "channels": [{ "server": "channel", "displayName": "BayChat" }]
+  "channels": [
+    {
+      "server": "channel",
+      "displayName": "BayChat"
+    }
+  ]
 }

package/README.md

@@ -9,8 +9,10 @@ This uses the separately deployed remote protocol 1.10.
 When login really needs renewal, an agent can run `baychat login --start`, show
 the approval link immediately, then run `baychat login --finish` once you approve.
 There is no waiting login process. Reconnect BayChat in the client afterwards.
-`baychat login --help` displays help without starting authentication. Login
-network requests time out after 15 seconds instead of waiting indefinitely.
+`--help` (or `-h`) on any command prints its usage and runs nothing — `baychat update --help`
+does not update. The one exception is `baychat claude`, whose arguments are all Claude Code's:
+`baychat claude --help` is Claude Code's own help. Login network requests time out after 15
+seconds instead of waiting indefinitely.
 
 ## Coding sessions: one short command
 
@@ -117,6 +119,41 @@ a local Claude Code channel (as the `baychat` plugin, from https://baychat.io/cl
 and the skill calls its `listen` tool instead of opening a Monitor: the channel holds the
 feed, reconnects by itself, and wakes the session only when a message arrives. Started
 without the flag, `listen` answers `inactive` and the Monitor path above is used.
+The channel needs **Node 22 or newer** (its built-in WebSocket; the relay's WebSocket needs
+it too). On Node 20 `connect claude` says so, and `baychat doctor` fails the `channel` and
+`relay` rows. A computer that still has the old skill-only `baychat` plugin (from the GitHub
+catalog of the same name) gets it replaced; `connect` reports the channel added only when
+the installed plugin actually declares it.
+
+To keep the system Node at 20 for other projects, run only `baychat` on Node 22 (Linux/WSL with
+systemd; details in [`CLAUDE_CODE_CHANNEL.md`](../../docs/features/CLAUDE_CODE_CHANNEL.md)):
+unpack Node 22 into `~/.local/node22`, then put a wrapper `~/.local/bin/baychat` ahead of npm's
+global `bin` on `PATH` (Claude Code starts the channel from `PATH`, so it gets Node 22 too).
+`~/.local/npm-global` below is one machine's npm prefix: write yours (`npm prefix -g`) as a
+literal path — the wrapper runs on every status-line refresh, so it must not call npm.
+
+```sh
+#!/bin/sh
+exec "$HOME/.local/node22/bin/node" "$HOME/.local/npm-global/lib/node_modules/baychat/dist/index.js" "$@"
+```
+
+and a drop-in `~/.config/systemd/user/baychat-relay.service.d/node22.conf` for the relay, then
+`systemctl --user daemon-reload && systemctl --user restart baychat-relay`:
+
+```ini
+[Service]
+ExecStart=
+ExecStart=%h/.local/node22/bin/node %h/.local/npm-global/lib/node_modules/baychat/dist/index.js relay start --foreground
+```
+
+`baychat relay status` should then read `transport: websocket (connected)`. To revert, delete
+both files, `daemon-reload`, restart the relay, and run `baychat update`.
+
+**Claude Code background agents** (`claude --bg`, `claude agents`) do not get the channel today:
+their `listen` answers inactive and they use the Monitor. Claude Code also retires an idle
+background agent after about an hour, which ends its Monitor or channel with it — pin the agent
+with **Ctrl+T** in `claude agents` to keep it. A session whose process is gone is not woken
+again: the default join registers nothing the relay could resume.
 
 The Windows relay runs without a visible console, including after login and
 network reconnects. Incoming messages appear as `@Sender` in the coding task.
@@ -317,7 +354,8 @@ 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 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 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 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) |
 | `baychat mcp` | Run a local **stdio MCP server** so MCP-aware clients (Claude Desktop, Claude Code, Cursor) get BayChat as native tools (see below) |
 | `baychat mcp-config [--client codex\|cursor\|desktop]` | Print a paste-ready config that points another MCP client at the **remote** BayChat server. No `--client` lists what's supported (see [Other MCP clients](#other-mcp-clients)) |

package/dist/approve-hook.js

@@ -33,13 +33,16 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
+exports.MAX_CLAUDE_HOPS = exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
 exports.allowDecision = allowDecision;
 exports.denyDecision = denyDecision;
 exports.describeToolRequest = describeToolRequest;
 exports.composeQuestion = composeQuestion;
 exports.decideApproval = decideApproval;
 exports.readStdin = readStdin;
+exports.sessionFromClaude = sessionFromClaude;
+exports.parseEtime = parseEtime;
+exports.decideApprovalOrDefer = decideApprovalOrDefer;
 exports.cmdApproveHook = cmdApproveHook;
 // `baychat approve-hook` — the Claude Code PermissionRequest hook that moves a terminal
 // permission prompt onto a phone.
@@ -79,12 +82,22 @@ exports.cmdApproveHook = cmdApproveHook;
 //   2. STDOUT IS THE DECISION CHANNEL. Nothing else may ever be written to it — "Stdout must
 //      contain only the JSON object". All diagnostics go to stderr.
 //
+// THE ONE EXCEPTION: `--session-from-claude` before the session has joined. `baychat claude` and
+// `baychat start` install this hook before the session has a name; until the channel records the
+// name (channel/claude-link.ts) there is no session a card could belong to. Then — and only then —
+// this prints NOTHING and exits 0, and Claude Code shows its own terminal dialog. That is not an
+// allow: it is the ordinary permission prompt, answered by the person who just ran the command at
+// that very terminal. Every other path, including every failure once a session WAS found, still
+// ends in an explicit decision.
+//
 // The card itself never expires: the ApprovalRequest row stays PENDING for as long as it takes,
 // exactly like a terminal prompt. Our deadline bounds only how long THIS PROCESS waits, and it
 // exists solely because the alternative (being killed by the handler timeout) would allow.
+const child_process_1 = require("child_process");
 const os = __importStar(require("os"));
 const api_1 = require("./api");
 const config_1 = require("./config");
+const claude_link_1 = require("./channel/claude-link");
 function allowDecision() {
     return {
         hookSpecificOutput: {
@@ -405,8 +418,82 @@ function readStdin(stream = process.stdin, timeoutMs = 10_000) {
     });
 }
 // ─── The command ─────────────────────────────────────────────────────────────
+// ─── --session-from-claude ───────────────────────────────────────────────────
+/** How many ancestors of the hook process are searched for the Claude Code that ran it. The hook
+ *  is normally its direct child (exec form); the slack covers a wrapper shell or two. */
+exports.MAX_CLAUDE_HOPS = 4;
+/**
+ * The BayChat session of the Claude Code this hook runs under, or undefined when it has not joined
+ * (or cannot be found). NEVER THROWS: any failure is "not found", which leaves the prompt to
+ * Claude Code's own dialog.
+ */
+function sessionFromClaude(deps = {}) {
+    const parentOf = deps.parentOf ?? psParentOf;
+    const isAlive = deps.isAlive ?? claude_link_1.pidAlive;
+    const readLink = deps.readLink ?? ((pid) => (0, claude_link_1.readClaudeLink)(pid));
+    const ageMs = deps.ageMs ?? psAgeMs;
+    const now = deps.now ?? Date.now;
+    try {
+        let pid = deps.ppid ?? process.ppid;
+        for (let hop = 0; hop < exports.MAX_CLAUDE_HOPS && pid !== undefined && pid > 1; hop++) {
+            const link = readLink(pid);
+            if (link && isAlive(pid)) {
+                // A file older than the process it is named after was left by an earlier process that
+                // had the same pid: not this Claude Code's session.
+                const age = ageMs(pid);
+                const written = Date.parse(link.writtenAt);
+                const stale = age !== undefined && Number.isFinite(written) && written < now() - age - 5_000;
+                if (!stale)
+                    return link.session;
+            }
+            pid = parentOf(pid);
+        }
+    }
+    catch {
+        // Not found. See above: no decision, the terminal dialog — never an allow by this code.
+    }
+    return undefined;
+}
+function psField(pid, field) {
+    if (process.platform === "win32")
+        return undefined;
+    const r = (0, child_process_1.spawnSync)("ps", ["-o", `${field}=`, "-p", String(pid)], { encoding: "utf8", timeout: 2_000 });
+    if (r.error || r.status !== 0)
+        return undefined;
+    const out = String(r.stdout ?? "").trim();
+    return out || undefined;
+}
+function psParentOf(pid) {
+    const n = Number(psField(pid, "ppid"));
+    return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+function psAgeMs(pid) {
+    const etime = psField(pid, "etime");
+    return etime ? parseEtime(etime) : undefined;
+}
+/** `ps -o etime` → ms: `[[dd-]hh:]mm:ss`. */
+function parseEtime(text) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(text.trim());
+    if (!m)
+        return undefined;
+    const [d, h, min, sec] = [m[1], m[2], m[3], m[4]].map((v) => Number(v ?? 0));
+    return (((d * 24 + h) * 60 + min) * 60 + sec) * 1000;
+}
+/**
+ * The decision for one hook run, or null for "no decision": `--session-from-claude` (and no
+ * `--session`) while the Claude Code it runs under has not joined a session.
+ */
+async function decideApprovalOrDefer(rawStdin, argv = [], deps = {}) {
+    const rest = argv.filter((a) => a !== "--session-from-claude");
+    if (rest.length === argv.length || rest.includes("--session"))
+        return decideApproval(rawStdin, rest, deps);
+    const session = sessionFromClaude(deps.claude);
+    if (session === undefined)
+        return null;
+    return decideApproval(rawStdin, ["--session", session, ...rest], deps);
+}
 /**
- * `baychat approve-hook [--session <name>] [--timeout <seconds>]`
+ * `baychat approve-hook [--session <name> | --session-from-claude] [--timeout <seconds>]`
  *
  * Always returns 0. A non-zero exit is a non-blocking error to Claude Code, which means the tool
  * call PROCEEDS — so exiting 1 on failure would be precisely backwards.
@@ -414,7 +501,7 @@ function readStdin(stream = process.stdin, timeoutMs = 10_000) {
 async function cmdApproveHook(argv = [], stdin = process.stdin) {
     let decision;
     try {
-        decision = await decideApproval(await readStdin(stdin), argv);
+        decision = await decideApprovalOrDefer(await readStdin(stdin), argv);
     }
     catch (err) {
         // decideApproval does not throw; readStdin does not reject. This is here anyway, because the
@@ -422,6 +509,9 @@ async function cmdApproveHook(argv = [], stdin = process.stdin) {
         process.stderr.write(`baychat approve-hook: ${err instanceof Error ? err.message : String(err)}\n`);
         decision = denyClosed("the approval gate could not run");
     }
+    // No decision: `--session-from-claude` before the session joined — Claude Code's own dialog.
+    if (decision === null)
+        return 0;
     // The single write to stdout, and the only one in this file.
     process.stdout.write(`${JSON.stringify(decision)}\n`);
     return 0;

package/dist/channel/claude-link.js

@@ -0,0 +1,145 @@
+"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.claudeSessionsDir = claudeSessionsDir;
+exports.claudeLinkPath = claudeLinkPath;
+exports.writeClaudeLink = writeClaudeLink;
+exports.removeClaudeLink = removeClaudeLink;
+exports.readClaudeLink = readClaudeLink;
+exports.pidAlive = pidAlive;
+exports.realClaudeLink = realClaudeLink;
+/**
+ * Which BayChat session a running Claude Code is — written by the channel, read by the hook.
+ *
+ * `baychat claude` / `baychat start` launch Claude Code with a PermissionRequest hook
+ * (`approve-hook --session-from-claude`) before the session has a name: it is chosen and joined
+ * inside the session, later. So once the channel's `listen` goes active, the channel server —
+ * a child Claude Code started — writes `~/.baychat/claude-sessions/<its parent pid>.json`
+ * = `{session, writtenAt}`. The hook, also a child of that Claude Code, walks up its own
+ * ancestors to find the file (approve-hook.ts) and asks for the card in that session's name.
+ *
+ * The file is private (0600 in a 0700 folder), removed when the feed stops or the channel exits,
+ * and replaced when the same Claude Code listens for another session. A file left behind by a
+ * crash is ignored by the hook once its pid is dead, and swept here on the next write.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../config");
+function claudeSessionsDir() {
+    return path.join((0, config_1.configDir)(), "claude-sessions");
+}
+function claudeLinkPath(pid, dir = claudeSessionsDir()) {
+    return path.join(dir, `${pid}.json`);
+}
+/** Write the link for Claude Code `pid`, sweeping files whose Claude Code is gone. */
+function writeClaudeLink(pid, session, opts = {}) {
+    const dir = opts.dir ?? claudeSessionsDir();
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    sweepDeadLinks(dir, opts.isAlive ?? pidAlive);
+    const file = claudeLinkPath(pid, dir);
+    const record = { session, writtenAt: (opts.now ?? (() => new Date()))().toISOString() };
+    // Write-then-rename, so the hook never reads half a file.
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 0o600 });
+    fs.chmodSync(tmp, 0o600);
+    fs.renameSync(tmp, file);
+}
+/** Remove the link for `pid` — only while it still names `session`, so a newer listen's link stays. */
+function removeClaudeLink(pid, session, dir = claudeSessionsDir()) {
+    const file = claudeLinkPath(pid, dir);
+    if (session !== undefined && readClaudeLink(pid, dir)?.session !== session)
+        return;
+    fs.rmSync(file, { force: true });
+}
+/** The link for `pid`, or undefined when absent or not well-formed. */
+function readClaudeLink(pid, dir = claudeSessionsDir()) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(claudeLinkPath(pid, dir), "utf8"));
+        if (typeof raw.session !== "string" || !raw.session.trim() || raw.session.length > 60 || typeof raw.writtenAt !== "string")
+            return undefined;
+        return { session: raw.session, writtenAt: raw.writtenAt };
+    }
+    catch {
+        return undefined;
+    }
+}
+function sweepDeadLinks(dir, isAlive) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        const m = /^(\d+)\.json$/.exec(name);
+        if (m && !isAlive(Number(m[1])))
+            fs.rmSync(path.join(dir, name), { force: true });
+    }
+}
+/** Is `pid` a live process? EPERM means it exists but is someone else's — still alive. */
+function pidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 1)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** The real link: keyed by this process's parent — the Claude Code that started the channel server. */
+function realClaudeLink(log, pid = process.ppid) {
+    return {
+        write: (session) => {
+            try {
+                writeClaudeLink(pid, session);
+            }
+            catch (err) {
+                // Approvals then stay in the terminal for this session: the hook finds no link and says nothing.
+                log(`could not record session ${session} for approvals: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        remove: (session) => {
+            try {
+                removeClaudeLink(pid, session);
+            }
+            catch (err) {
+                log(`could not remove the approvals link: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+    };
+}

package/dist/channel/feed.js

@@ -78,8 +78,33 @@ class ChannelFeed {
     }
     /** Stop for good: no reconnect, no watchdog. Used on replace and on process exit. */
     stop() {
+        const was = this.state;
         this.state = "stopped";
         this.teardown();
+        if (was !== "stopped")
+            this.deps.onStop?.();
+    }
+    /**
+     * Close the open socket and reconnect with the last cursor — a fresh mint, so the ticket says
+     * what is true NOW (e.g. whether this computer's relay runs the session's commands). The
+     * cursor replays the gap: nothing is lost and no event is pushed. A feed between sockets
+     * needs nothing: its next mint already reads the current state.
+     */
+    reopen(why) {
+        if (this.state !== "open")
+            return;
+        this.log(`feed for ${this.deps.session} ${why}; reopening`);
+        this.generation++;
+        const socket = this.socket;
+        this.socket = undefined;
+        try {
+            socket?.close(1000, "Reopening");
+        }
+        catch {
+            /* Already gone. */
+        }
+        this.attempt = 0;
+        this.scheduleReconnect("reopen");
     }
     teardown() {
         this.generation++;
@@ -209,18 +234,7 @@ class ChannelFeed {
         if (this.state === "open") {
             const seen = late ? "disconnected" : await this.deps.status();
             if (this.state === "open" && seen === "disconnected") {
-                this.log(`feed for ${this.deps.session} ${late ? "outlived a sleep" : "is not seen by the server"}; reopening`);
-                this.generation++;
-                const socket = this.socket;
-                this.socket = undefined;
-                try {
-                    socket?.close(1000, "Reopening");
-                }
-                catch {
-                    /* Already gone. */
-                }
-                this.attempt = 0;
-                this.scheduleReconnect("watchdog");
+                this.reopen(late ? "outlived a sleep" : "is not seen by the server");
             }
         }
         else if (late && this.state === "retrying" && this.retryTimer !== undefined) {

package/dist/channel/launch.js

@@ -33,18 +33,17 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CHANNEL_ENV = exports.CHANNEL_LAUNCH_COMMAND = exports.PLUGIN_MARKETPLACE_URL = exports.CHANNEL_LAUNCH_ARGS = exports.CHANNEL_MIN_CLAUDE = void 0;
+exports.CHANNEL_ENV = exports.CHANNEL_LAUNCH_COMMAND = exports.CHANNEL_LAUNCH_ARGS = exports.CHANNEL_MIN_CLAUDE = void 0;
 exports.parseClaudeVersion = parseClaudeVersion;
 exports.claudeSupportsChannel = claudeSupportsChannel;
 exports.channelLaunchFor = channelLaunchFor;
 exports.cmdClaude = cmdClaude;
+exports.terminalApprovalArgs = terminalApprovalArgs;
+exports.startsInteractiveSession = startsInteractiveSession;
 exports.claudeChannelAddArgs = claudeChannelAddArgs;
 exports.registerChannelWithClaude = registerChannelWithClaude;
 exports.claudeUserConfigPath = claudeUserConfigPath;
 exports.channelRegistered = channelRegistered;
-exports.claudeUserSettingsPath = claudeUserSettingsPath;
-exports.pluginEnabled = pluginEnabled;
-exports.installPluginWithClaude = installPluginWithClaude;
 /**
  * Getting the channel into Claude Code: registering the server, and starting sessions with it on.
  *
@@ -56,8 +55,11 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const multiplexer_launch_1 = require("../multiplexer-launch");
 const runtime_binary_1 = require("../runtime-binary");
 const detect_1 = require("./detect");
+const plugin_1 = require("./plugin");
+const approval_settings_1 = require("../relay/launcher/approval-settings");
 /**
  * The first Claude Code this is switched on for. Channels exist from earlier releases, but
  * 2.1.234 is where Claude Code started sending a channel only what it registered for the
@@ -82,8 +84,6 @@ function claudeSupportsChannel(version) {
 }
 /** The arguments that switch the hand-registered channel server on. */
 exports.CHANNEL_LAUNCH_ARGS = [detect_1.DEV_CHANNELS_FLAG, detect_1.CHANNEL_FLAG_VALUE];
-/** 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";
 /** What to type to start Claude Code with the channel on. */
 exports.CHANNEL_LAUNCH_COMMAND = "baychat claude";
 /**
@@ -101,7 +101,7 @@ function channelLaunchFor(claudePath, deps = {}) {
     // move to the plugin; Claude Code then keeps the hand-registered server and hides the plugin's
     // duplicate, so naming both is what keeps the channel switched on either way.
     const entries = [
-        ...((deps.plugin ?? (() => pluginEnabled()))() ? [detect_1.PLUGIN_FLAG_VALUE] : []),
+        ...((deps.plugin ?? (() => (0, plugin_1.pluginEnabled)()))() ? [detect_1.PLUGIN_FLAG_VALUE] : []),
         ...((deps.registered ?? (() => channelRegistered()))() ? [detect_1.CHANNEL_FLAG_VALUE] : []),
     ];
     if (!entries.length)
@@ -117,10 +117,13 @@ function probeVersion(claudePath) {
     return probe.error || probe.status !== 0 ? undefined : String(probe.stdout ?? "");
 }
 /**
- * `baychat claude [args…]` — Claude Code with the BayChat channel switched on, in this terminal.
- * No multiplexer (that is `baychat start`), nothing else changed: every argument is passed on.
+ * `baychat claude [args…]` — Claude Code with the BayChat channel switched on. Every argument is
+ * passed on. An interactive session starts inside tmux (or screen) when one is installed, so
+ * `/clear` from the phone can reach it — through the launcher `baychat start` uses
+ * (multiplexer-launch.ts) — in a NEW multiplexer session each time (`claude-<pid>`), never one
+ * another terminal is already in. Anything else (`-p`, `--bg`, `mcp list`, …) runs right here.
  */
-function cmdClaude(args) {
+async function cmdClaude(args) {
     const binary = (0, runtime_binary_1.resolveRuntimeBinary)("claude", (0, runtime_binary_1.currentBinaryEnv)());
     if (!binary.ok) {
         console.error(`Could not start Claude Code: ${binary.reason}`);
@@ -129,13 +132,54 @@ function cmdClaude(args) {
     const launch = channelLaunchFor(binary.path);
     if (!launch.on)
         console.error(`Starting Claude Code without the BayChat channel: ${launch.why}. Messages will use the Monitor.`);
-    const result = (0, node_child_process_1.spawnSync)(binary.path, [...launch.args, ...args], { stdio: "inherit", env: { ...process.env, ...launch.env } });
-    if (result.error) {
-        console.error(`Could not start Claude Code: ${result.error.message}`);
-        return 1;
+    const interactive = startsInteractiveSession(args);
+    const approvals = interactive && launch.on ? terminalApprovalArgs(args) : [];
+    const program = { binary: binary.path, args: [...launch.args, ...approvals, ...args], env: { ...launch.env } };
+    return interactive ? (0, multiplexer_launch_1.launchAgent)(program, { kind: "fresh", prefix: "claude" }) : (0, multiplexer_launch_1.runHere)(program);
+}
+/**
+ * `--settings <file>` that sends this session's permission prompts to BayChat once it has joined
+ * (the owner's decision, 2026-10-05: approvals come inside BayChat for every session BayChat's
+ * launcher starts). The file holds only the PermissionRequest hook with `--session-from-claude`
+ * (relay/launcher/approval-settings.ts); until the session joins, prompts stay in this terminal.
+ *
+ * Only for an interactive Claude Code with the channel on: the channel is what records the
+ * session's name for the hook (claude-link.ts), so without it the hook could never find one.
+ * Never blocks the start — a file that cannot be written means prompts stay in the terminal.
+ */
+function terminalApprovalArgs(userArgs, deps = {}) {
+    const say = deps.say ?? ((line) => console.error(line));
+    if (userArgs.some((a) => a === "--settings" || a.startsWith("--settings="))) {
+        say("BayChat: you passed your own --settings, so approvals for this session stay in this terminal.");
+        return [];
+    }
+    try {
+        const file = (deps.write ?? ((cli) => (0, approval_settings_1.writeTerminalApprovalSettings)(cli)))((deps.cli ?? approval_settings_1.currentCliLaunch)());
+        say("BayChat: once this session joins, its approvals come to BayChat.");
+        return ["--settings", file];
     }
-    return result.status ?? 0;
+    catch (err) {
+        say(`BayChat: approvals stay in this terminal (could not write their settings: ${err instanceof Error ? err.message : String(err)}).`);
+        return [];
+    }
+}
+/**
+ * Do these Claude Code arguments start an interactive session — the only thing worth putting in
+ * a multiplexer? Not a one-shot (`-p`), a background agent (`--bg`), a version or help line, or
+ * a subcommand (`claude --help`, 2.1.289): those print and exit, and inside a tmux session that
+ * closes with them, the output would be gone before anyone read it.
+ */
+function startsInteractiveSession(args) {
+    if (args.some((a) => ONE_SHOT_FLAGS.has(a.split("=")[0])))
+        return false;
+    const first = args[0];
+    return !(first !== undefined && !first.startsWith("-") && CLAUDE_SUBCOMMANDS.has(first));
 }
+const ONE_SHOT_FLAGS = new Set(["-p", "--print", "--bg", "--background", "-v", "--version", "-h", "--help"]);
+const CLAUDE_SUBCOMMANDS = new Set([
+    "agents", "attach", "auth", "auto-mode", "config", "doctor", "gateway", "import", "install", "kill", "logs", "mcp",
+    "migrate-installer", "plugin", "plugins", "purge", "respawn", "rm", "setup-token", "stop", "update", "upgrade",
+]);
 /** `claude mcp add` argv for the channel server: this CLI by absolute path, run as `channel`. */
 function claudeChannelAddArgs(launch) {
     return ["mcp", "add", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY, "--", launch.node, launch.entry, "channel"];
@@ -168,33 +212,3 @@ function channelRegistered(file = claudeUserConfigPath(), read = (p) => fs.readF
         return false;
     }
 }
-/** 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(file = claudeUserSettingsPath(), read = (p) => fs.readFileSync(p, "utf8")) {
-    try {
-        const parsed = JSON.parse(read(file));
-        return parsed?.enabledPlugins?.[detect_1.PLUGIN_ID] === true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Install BayChat as a Claude Code plugin: add the catalog from baychat.io, install from it (the
- * plugin itself is fetched from the `baychat` npm package), then remove the hand-registered
- * server, which would otherwise hide the plugin's. Returns false at the first step that fails,
- * leaving whatever worked before untouched — the caller then registers the server by hand.
- */
-function installPluginWithClaude(run) {
-    const added = run(["plugin", "marketplace", "add", exports.PLUGIN_MARKETPLACE_URL]);
-    if (added.status !== 0 && !/already/i.test(added.stderr))
-        return false;
-    const installed = run(["plugin", "install", detect_1.PLUGIN_ID]);
-    if (installed.status !== 0 && !/already installed/i.test(installed.stderr))
-        return false;
-    run(["mcp", "remove", "--scope", "user", detect_1.CHANNEL_MCP_ENTRY]); // Absent is fine.
-    return true;
-}