baychat 0.32.0 → 0.32.2

package/dist/relay/daemon.js

@@ -74,6 +74,10 @@ const transport_1 = require("./transport");
 const watermarks_1 = require("./watermarks");
 const bay_relays_1 = require("./bay-relays");
 const loop_1 = require("./launcher/loop");
+const log_line_1 = require("./log-line");
+const handle_1 = require("./launcher/handle");
+const multiplexer_1 = require("./launcher/multiplexer");
+const approval_settings_1 = require("./launcher/approval-settings");
 /**
  * How long a failed resume-id discovery is believed before it is retried.
  *
@@ -82,6 +86,8 @@ const loop_1 = require("./launcher/loop");
  * unanswerable delivery expensive as well as pending.
  */
 const DISCOVERY_INTERVAL_MS = 10 * 60_000;
+/** The launch records are checked against the multiplexer at most this often (`dropEndedLaunches`). */
+const LAUNCH_CHECK_MIN_MS = 15_000;
 class RelayDaemon {
     registry = new registry_1.SessionRegistry();
     acpQueue = new turn_queue_1.AcpTurnQueue();
@@ -134,6 +140,10 @@ class RelayDaemon {
     discovery;
     spawnHeadless;
     isAlive;
+    forgetEndedLaunchFn;
+    forgetEndedLaunchesFn;
+    /** When the launch records were last checked against the multiplexer (`dropEndedLaunches`). */
+    launchesCheckedAt = 0;
     /**
      * Sessions with a headless turn running right now — the one-session lease.
      *
@@ -199,7 +209,9 @@ class RelayDaemon {
     /** A launch from BayChat is being carried out (the launcher's `onLaunch`). */
     launching = false;
     constructor(opts = {}) {
-        this.log = opts.log ?? ((line) => console.log(`[relay] ${line}`));
+        // Every line carries when it happened (ISO, UTC): relay.log is read after the fact, against the
+        // server's own UTC log lines (2026-10-16: a STOP could not be placed in time).
+        this.log = opts.log ?? ((line) => console.log((0, log_line_1.relayLogLine)(line)));
         this.onListening = opts.onListening;
         this.startLauncherFn = opts.startLauncher ?? loop_1.startLauncher;
         this.autoUpdateStatus = opts.autoUpdateStatus;
@@ -245,6 +257,8 @@ class RelayDaemon {
         this.discovery = opts.discovery ?? {};
         this.spawnHeadless = opts.spawnHeadless ?? adapters_1.runHeadless;
         this.isAlive = opts.isAlive ?? parent_watch_1.processIsAlive;
+        this.forgetEndedLaunchFn = opts.forgetEndedLaunch ?? ((name) => (0, handle_1.forgetEndedLaunch)(name, { run: multiplexer_1.realRun, launchDir: (0, approval_settings_1.launchDir)() }));
+        this.forgetEndedLaunchesFn = opts.forgetEndedLaunches ?? (() => (0, handle_1.forgetEndedLaunches)({ run: multiplexer_1.realRun, launchDir: (0, approval_settings_1.launchDir)() }));
         this.reattachGraceMs = opts.reattachGraceMs ?? 4000;
         this.resolveBinary =
             opts.resolveBinary ??
@@ -354,6 +368,11 @@ class RelayDaemon {
                 onLaunch: (busy) => {
                     this.launching = busy;
                 },
+                // A session the launcher stopped is forgotten here too, not kept as a dead registration.
+                forgetSession: (name) => {
+                    if (this.registry.remove(name))
+                        this.log(`session ${name} stopped by its launcher: forgotten`);
+                },
             }).catch((err) => this.log(`launcher stopped: ${err instanceof Error ? err.message : String(err)}`));
         }
         this.log(`listening on ${sockPath} (pid ${process.pid}) as device "${device.user.name}"`);
@@ -374,6 +393,8 @@ class RelayDaemon {
                 // never had to route an event to — skipping it re-baselines it at "now".
                 this.watermarks.noteLiveSessions(names);
                 const dropped = this.registry.pruneToLive(names);
+                this.dropDeadChannelSessions();
+                this.dropEndedLaunches();
                 for (const name of dropped) {
                     this.log(`session ended server-side, dropped: ${name}`);
                     // A name reused later is a new session: nothing kept for the old one may reach it.
@@ -1580,6 +1601,7 @@ class RelayDaemon {
                 this.channels.delete(session);
                 this.registry.setAttached(session, false);
                 this.log(`channel disconnected: ${session} — its commands are refused until it reconnects`);
+                this.dropDeadChannelSessions();
             }
         };
         sock.on("close", drop);
@@ -1604,6 +1626,44 @@ class RelayDaemon {
         const where = frame.pane?.kind === "tmux" ? `tmux pane ${frame.pane.pane}` : (frame.pane?.kind ?? "no multiplexer");
         this.log(`channel registered: ${frame.session} (${frame.runtime}, commands only, ${where})`);
     }
+    /**
+     * Forget every channel session that is DEAD: its channel link is closed and its Claude Code
+     * process (`ownerPid`) is gone — from relay-sessions.json, and from launch/started.json when its
+     * launcher session has ended too. Run when a channel link closes and on every session poll, so a
+     * session that died without End is not kept as a registration the relay still believes in
+     * (2026-10-16: mac_motion stayed in both files with no tmux and no claude left).
+     *
+     * A link that closed while its process lives is a reconnect in progress, and is kept. A
+     * registration with no pid is judged by its link alone once the server no longer lists it.
+     */
+    dropDeadChannelSessions() {
+        for (const target of this.registry.all()) {
+            if (target.delivery !== "channel" || this.channelLinked(target.name))
+                continue;
+            if (target.ownerPid === undefined || this.isAlive(target.ownerPid))
+                continue;
+            this.registry.remove(target.name);
+            const launch = this.forgetEndedLaunchFn(target.name) ? " and its launch record" : "";
+            this.log(`channel session ${target.name} is gone (process ${target.ownerPid} not running): dropped its registration${launch}`);
+        }
+    }
+    /**
+     * Forget every launch whose launcher session has ended on its own (launch/started.json), and
+     * say so the way the channel sweep above does. That sweep only sees a session whose channel
+     * registered with THIS relay; a launch whose channel never did (2026-10-16, the Mac: `qa_kill`'s
+     * claude killed by hand, `bc-qa_kill` gone, still listed minutes later, nothing in relay.log)
+     * is caught here. Session polls can come with every event batch, so this asks the multiplexer
+     * at most every LAUNCH_CHECK_MIN_MS.
+     */
+    dropEndedLaunches() {
+        const now = Date.now();
+        if (now - this.launchesCheckedAt < LAUNCH_CHECK_MIN_MS)
+            return;
+        this.launchesCheckedAt = now;
+        for (const gone of this.forgetEndedLaunchesFn()) {
+            this.log(`launched session ${gone.name} is gone (its ${gone.multiplexer} session is not running): dropped its launch record`);
+        }
+    }
     channelLinked(session) {
         const sock = this.channels.get(session);
         return !!sock && !sock.destroyed;

package/dist/relay/launcher/approval-settings.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TERMINAL_SETTINGS_FILE = exports.UNATTENDED_SETTINGS = exports.JOIN_ALLOW = void 0;
+exports.LAUNCH_MCP_ENTRY = exports.TERMINAL_SETTINGS_FILE = exports.UNATTENDED_SETTINGS = exports.OWN_CONNECTION_ALLOW = exports.JOIN_ALLOW = void 0;
 exports.approvalPathFor = approvalPathFor;
 exports.launchDir = launchDir;
 exports.approvalSettingsPath = approvalSettingsPath;
@@ -45,11 +45,18 @@ exports.approvalsDir = approvalsDir;
 exports.writeTerminalApprovalSettings = writeTerminalApprovalSettings;
 exports.currentCliLaunch = currentCliLaunch;
 exports.writeApprovalSettings = writeApprovalSettings;
+exports.launchMcpConfigPath = launchMcpConfigPath;
+exports.launchMcpConfig = launchMcpConfig;
+exports.writeLaunchMcpConfig = writeLaunchMcpConfig;
+exports.removeLaunchFiles = removeLaunchFiles;
 exports.removeApprovalSettings = removeApprovalSettings;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const approve_hook_1 = require("../../approve-hook");
 const config_1 = require("../../config");
+const bays_1 = require("../../bays");
+Object.defineProperty(exports, "LAUNCH_MCP_ENTRY", { enumerable: true, get: function () { return bays_1.LAUNCH_MCP_ENTRY; } });
+const detect_1 = require("../../channel/detect");
 const opt_in_1 = require("../../denied/opt-in");
 /** Always `"hook"` for now: Claude Code's channel permission relay is behind a flag that is off. */
 function approvalPathFor(_sessionName) {
@@ -76,6 +83,18 @@ exports.JOIN_ALLOW = [
     "mcp__baychat_channel__*",
     "mcp__plugin_baychat_channel__*",
 ];
+/**
+ * The allowlist of a session launched by a relay on a setup of its own (relay-identity.ts,
+ * `--strict-mcp-config`): its own `baychat-relay` connection and the channel server in its own
+ * MCP file — and NOT `mcp__baychat__*`, the computer's user-wide production login (Windows QA
+ * 2026-10-16), nor the plugin's channel, which strict mode does not load.
+ */
+exports.OWN_CONNECTION_ALLOW = [
+    "Bash(baychat skill:*)",
+    "Bash(baychat session-name:*)",
+    `mcp__${bays_1.LAUNCH_MCP_ENTRY}__*`,
+    "mcp__baychat_channel__*",
+];
 /** The PermissionRequest hook block, running approve-hook by absolute node + entry with `flags`. */
 function permissionHook(cli, flags) {
     return {
@@ -159,13 +178,14 @@ exports.UNATTENDED_SETTINGS = { skillOverrides: { "auto-mode-setup": "off" } };
 /**
  * The settings object for a session started from BayChat. Pure; the test pins its exact content.
  * `bayEntry`: the MCP connection the session joins on, when it is not the default `baychat`
- * (a computer logged in to several Bays) — its tools are join tools too.
+ * (a computer logged in to several Bays) — its tools are join tools too. `ownConnection`: a relay
+ * on a setup of its own (`OWN_CONNECTION_ALLOW`).
  */
-function approvalSettings(sessionName, cli, bayEntry) {
+function approvalSettings(sessionName, cli, bayEntry, ownConnection = false) {
     const extra = bayEntry && bayEntry !== "baychat" ? [`mcp__${bayEntry}__*`] : [];
     return {
         ...exports.UNATTENDED_SETTINGS,
-        permissions: { allow: [...exports.JOIN_ALLOW, ...extra] },
+        permissions: { allow: ownConnection ? [...exports.OWN_CONNECTION_ALLOW] : [...exports.JOIN_ALLOW, ...extra] },
         hooks: permissionHook(cli, ["--session", sessionName]),
     };
 }
@@ -197,11 +217,48 @@ function currentCliLaunch() {
     return { node: fs.realpathSync(process.execPath), entry: fs.realpathSync(process.argv[1] ?? "") };
 }
 /** Write the session's settings file (0600) and return its path. `sessionName` must already be validated. */
-function writeApprovalSettings(sessionName, cli, dir = launchDir(), bayEntry) {
+function writeApprovalSettings(sessionName, cli, dir = launchDir(), bayEntry, ownConnection = false) {
     const file = approvalSettingsPath(sessionName, dir);
-    writePrivateJson(dir, file, withOptIn(approvalSettings(sessionName, cli, bayEntry), cli, ["--session", sessionName]));
+    writePrivateJson(dir, file, withOptIn(approvalSettings(sessionName, cli, bayEntry, ownConnection), cli, ["--session", sessionName]));
+    return file;
+}
+function launchMcpConfigPath(sessionName, dir = launchDir()) {
+    return path.join(dir, `${sessionName}.mcp.json`);
+}
+/**
+ * The `--mcp-config` content. Pure. The session runs with `--strict-mcp-config`, so this is the
+ * WHOLE of its MCP: the remote BayChat server (as `claude mcp add --transport http` writes it)
+ * and, for a channel launch, the channel server itself — the user-wide `baychat_channel` entry
+ * (or the plugin's) no longer loads, and `--dangerously-load-development-channels
+ * server:baychat_channel` must name a server that does. Same command `baychat connect claude`
+ * registers (`node <cli> channel`), with the relay's location variables (no secrets).
+ */
+function launchMcpConfig(server, channel) {
+    return {
+        mcpServers: {
+            [bays_1.LAUNCH_MCP_ENTRY]: {
+                type: "http",
+                url: `${server.baseUrl.replace(/\/+$/, "")}/api/mcp`,
+                headers: { Authorization: `Bearer ${server.token}` },
+            },
+            ...(channel ? { [detect_1.CHANNEL_MCP_ENTRY]: { type: "stdio", command: channel.cli.node, args: [channel.cli.entry, "channel"], env: channel.env } } : {}),
+        },
+    };
+}
+/**
+ * Write the session's own MCP config (0600 in the 0700 launch folder: it holds the Bay's token,
+ * like credentials.json) and return its path. Deleted with the settings file (`removeLaunchFiles`).
+ */
+function writeLaunchMcpConfig(sessionName, server, dir = launchDir(), channel) {
+    const file = launchMcpConfigPath(sessionName, dir);
+    writePrivateJson(dir, file, launchMcpConfig(server, channel));
     return file;
 }
+/** Delete every file a launch wrote for its session (settings, MCP config). Idempotent. */
+function removeLaunchFiles(sessionName, dir = launchDir()) {
+    removeApprovalSettings(sessionName, dir);
+    fs.rmSync(launchMcpConfigPath(sessionName, dir), { force: true });
+}
 /** Delete the session's settings file. Idempotent: an absent file is already deleted. */
 function removeApprovalSettings(sessionName, dir = launchDir()) {
     fs.rmSync(approvalSettingsPath(sessionName, dir), { force: true });

package/dist/relay/launcher/argv.js

@@ -23,6 +23,7 @@ exports.roomTitleProblem = roomTitleProblem;
  * PATH into the pane are the same code on every path. What differs here is only that a launch is
  * DETACHED (`-d` / `-dm`) — nobody is at the terminal — and carries `--settings` for approvals.
  */
+const detect_1 = require("../../channel/detect");
 const multiplexer_launch_1 = require("../../multiplexer-launch");
 /** Every launcher-made multiplexer session is named `bc-<session name>`. */
 exports.LAUNCH_SESSION_PREFIX = "bc-";
@@ -38,12 +39,19 @@ function multiplexerSessionName(sessionName) {
 exports.UNATTENDED_NOTE = "(Started from the BayChat app: nobody is at this keyboard. Never ask anything before you have joined; if you cannot join, say why in one line and stop.)";
 /**
  * The first message Claude Code receives: the BayChat skill, joining the chosen room — on the
- * named Bay connection when the computer has several, so the skill never asks which.
+ * named Bay connection when the computer has several, so the skill never asks which. With
+ * `ownConnection` (a relay on a setup of its own) the connection is named but no `--bay` is given:
+ * that session has one login, so there is no Bay to choose.
  */
-function baychatPrompt(sessionName, join, bayEntry) {
+function baychatPrompt(sessionName, join, bayEntry, ownConnection = false, channel = false) {
     const room = !join ? "" : "sessions" in join ? " --sessions" : "direct" in join ? " --private" : ` --group "${join.group}"`;
-    const bay = bayEntry ? ` --bay ${bayEntry}` : "";
-    const connection = bayEntry ? ` Use only the ${bayEntry} connection (its mcp__${bayEntry}__ tools).` : "";
+    // An own connection (`baychat-relay`) is not a Bay: as `--bay` the session passed it on to the
+    // channel's listen, which failed (Mac QA 2026-10-16). It is only named as the connection to use.
+    const bay = bayEntry && !ownConnection ? ` --bay ${bayEntry}` : "";
+    // "Use only …" alone read as "not the channel either": the session went straight to
+    // listen_messages + Monitor (Mac QA 2026-10-16). Its channel is named as part of it.
+    const ownChannel = ownConnection && channel ? ` and its channel (call mcp__${detect_1.CHANNEL_MCP_ENTRY}__listen first, with session "${sessionName}")` : "";
+    const connection = bayEntry ? ` Use only the ${bayEntry} connection (its mcp__${bayEntry}__ tools)${ownChannel}.` : "";
     return `/baychat ${sessionName}${room}${bay} ${exports.UNATTENDED_NOTE}${connection}`;
 }
 function buildLaunchCommand(input) {
@@ -51,9 +59,15 @@ function buildLaunchCommand(input) {
     const args = (0, multiplexer_launch_1.multiplexerArgv)(input.multiplexer, { kind: "detached", name, cwd: input.folder }, {
         binary: input.claudeBin,
         args: [
+            // FIRST, and closed by a flag. Claude Code's `--mcp-config <configs...>` is VARIADIC: placed
+            // just before the prompt it took the `/baychat …` line as a second config path and claude
+            // exited at once (ENAMETOOLONG, Mac QA 2026-10-16). `--strict-mcp-config` both ends the list
+            // and keeps the computer's user-wide servers (the default login's `baychat`) out of the
+            // session: an own connection is only ever written for a relay on a setup of its own.
+            ...(input.mcpConfigFile ? ["--mcp-config", input.mcpConfigFile, "--strict-mcp-config"] : []),
             ...input.channelArgs,
             ...(input.settingsFile ? ["--settings", input.settingsFile] : []),
-            baychatPrompt(input.sessionName, input.join, input.bayEntry),
+            baychatPrompt(input.sessionName, input.join, input.bayEntry, input.mcpConfigFile !== undefined, input.channelArgs.length > 0),
         ],
         env: input.env,
     });

package/dist/relay/launcher/handle.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONFIRM_DEADLINE_MS = exports.WARNING_POLL_MS = exports.WARNING_WATCH_MS = void 0;
 exports.handleLaunch = handleLaunch;
+exports.forgetEndedLaunch = forgetEndedLaunch;
+exports.forgetEndedLaunches = forgetEndedLaunches;
 exports.parseLaunch = parseLaunch;
 exports.launchBayEntry = launchBayEntry;
 const bays_1 = require("../../bays");
+const detect_1 = require("../../channel/detect");
 const policy_1 = require("../../launch/policy");
 const argv_1 = require("./argv");
 const approval_settings_1 = require("./approval-settings");
@@ -75,32 +78,51 @@ function startSession(launch, deps) {
     const live = (0, multiplexer_1.liveLaunchSessions)(multiplexer, deps.run);
     const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
     const started = pruneEnded((0, started_1.loadStarted)(recordFile), live, deps);
-    if (live.includes(launch.sessionName))
-        return refused("NAME_TAKEN");
-    if (live.length >= policy_1.MAX_SESSIONS_PER_COMPUTER)
-        return refused("CAP_REACHED");
-    if (started.filter((s) => s.spotId === spot.id).length >= spot.maxSessions)
+    if (live.includes(launch.sessionName)) {
+        // Said in relay.log (Windows QA 2026-10-16: refused with nothing logged). The app answers
+        // NAME_TAKEN with "Replace it", whose STOP reaches only a session this launcher started.
+        const own = started.some((s) => s.name === launch.sessionName);
+        deps.log(`launch ${launch.id}: refused, "${launch.sessionName}" is still running here (${multiplexer} session ${(0, argv_1.multiplexerSessionName)(launch.sessionName)}${own ? ", started by BayChat: Replace it can stop it" : ", not started by BayChat: stop it at this computer"})`);
+        // Not ours: Replace it could not stop it (its STOP is refused NOT_LAUNCHED), so say so with a
+        // code of its own and the app offers no Replace it (Mac QA 2026-10-16: a loop otherwise).
+        return refused(own ? "NAME_TAKEN" : "NAME_TAKEN_FOREIGN");
+    }
+    if (live.length >= policy_1.MAX_SESSIONS_PER_COMPUTER || started.filter((s) => s.spotId === spot.id).length >= spot.maxSessions) {
+        deps.log(`launch ${launch.id}: refused, too many sessions running (${live.length} here, the folder "${spot.label}" allows ${spot.maxSessions})`);
         return refused("CAP_REACHED");
+    }
     const binary = deps.resolveBinary(capabilities_1.RUNTIME_BINARY.claude);
     if (!binary.ok)
         return refused("RUNTIME_MISSING");
     // Monitor: no channel flag and no channel marker — the session listens with listen_messages + Monitor.
     const channel = launch.listen === "monitor" ? { args: [], env: {} } : deps.channelLaunch(binary.path);
-    const settingsFile = (0, approval_settings_1.approvalPathFor)(launch.sessionName) === "hook" ? (0, approval_settings_1.writeApprovalSettings)(launch.sessionName, deps.cli, deps.launchDir, bay.entry) : undefined;
+    // A relay on a setup of its own gives the session its own connection to the relay's server,
+    // with the launch's Bay login, and names it in the /baychat line (relay-identity.ts).
+    // It runs with --strict-mcp-config, so a channel launch carries its channel server in that file
+    // and names exactly that one on the channel flag (approval-settings.ts `launchMcpConfig`).
+    const own = deps.ownServer ? { baseUrl: deps.ownServer.baseUrl, token: bay.token ?? deps.ownServer.token } : null;
+    const ownChannel = own && channel.args.length > 0;
+    const mcpConfigFile = own
+        ? (0, approval_settings_1.writeLaunchMcpConfig)(launch.sessionName, own, deps.launchDir, ownChannel ? { cli: deps.cli, env: deps.relayEnv ?? {} } : undefined)
+        : undefined;
+    const channelArgs = ownChannel ? [detect_1.DEV_CHANNELS_FLAG, detect_1.CHANNEL_FLAG_VALUE] : channel.args;
+    const bayEntry = own ? approval_settings_1.LAUNCH_MCP_ENTRY : bay.entry;
+    const settingsFile = (0, approval_settings_1.approvalPathFor)(launch.sessionName) === "hook" ? (0, approval_settings_1.writeApprovalSettings)(launch.sessionName, deps.cli, deps.launchDir, bayEntry, own !== null) : undefined;
     const command = (0, argv_1.buildLaunchCommand)({
         multiplexer,
         sessionName: launch.sessionName,
         folder: folder.path,
         claudeBin: binary.path,
-        channelArgs: channel.args,
-        env: { ...channel.env, PATH: deps.pathEnv },
+        channelArgs,
+        env: { ...(deps.relayEnv ?? {}), ...channel.env, PATH: deps.pathEnv },
         settingsFile,
+        mcpConfigFile,
         join: launch.join,
-        bayEntry: bay.entry,
+        bayEntry,
     });
     const res = deps.run(command.file, command.args, { cwd: command.cwd, env: command.env });
     if (res.error || res.status !== 0) {
-        (0, approval_settings_1.removeApprovalSettings)(launch.sessionName, deps.launchDir);
+        (0, approval_settings_1.removeLaunchFiles)(launch.sessionName, deps.launchDir);
         deps.log(`launch ${launch.id}: ${command.file} failed: ${res.error?.message ?? (res.stderr.trim() || `exit ${res.status}`)}`);
         return { status: "FAILED", reason: "SPAWN_FAILED" };
     }
@@ -230,11 +252,15 @@ function stopSession(launch, deps) {
     if (!entry)
         return refused("NOT_LAUNCHED");
     const outcome = stopRecorded(entry, deps);
-    if (outcome === "not-running")
+    if (outcome === "not-running") {
+        deps.log(`launch ${launch.id}: "${entry.name}" was not running any more; its records are cleared`);
         return refused("NOT_RUNNING");
-    if (outcome === "failed")
+    }
+    if (outcome === "failed") {
+        deps.log(`launch ${launch.id}: could not stop "${entry.name}": its ${entry.multiplexer} session is still there`);
         return { status: "FAILED", reason: "STOP_FAILED" };
-    deps.log(`launch ${launch.id}: stopped "${entry.name}" for ${launch.requestedBy.name}`);
+    }
+    deps.log(`launch ${launch.id}: stopped "${entry.name}" for ${launch.requestedBy.name} — its ${entry.multiplexer} session is gone (checked)`);
     return { status: "STARTED" };
 }
 /**
@@ -243,27 +269,63 @@ function stopSession(launch, deps) {
  * the record, so a later STOP can try again.
  */
 function stopRecorded(entry, deps) {
-    const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
     const forget = () => {
-        (0, started_1.saveStarted)((0, started_1.loadStarted)(recordFile).filter((s) => s.name !== entry.name), recordFile);
-        (0, approval_settings_1.removeApprovalSettings)(entry.name, deps.launchDir);
+        forgetStarted(entry.name, deps.launchDir);
+        deps.forgetSession?.(entry.name);
     };
-    if (!(0, multiplexer_1.liveLaunchSessions)(entry.multiplexer, deps.run).includes(entry.name)) {
+    if (!(0, multiplexer_1.launchSessionExists)(entry.multiplexer, entry.name, deps.run)) {
         forget();
         return "not-running";
     }
-    if (!(0, multiplexer_1.killLaunchSession)(entry.multiplexer, entry.name, deps.run))
+    // The kill's own answer is not the proof: the session must be GONE (2026-10-16, mac_motion — a
+    // STOP reported "closed" and the owner still found it). A session still there is STOP_FAILED and
+    // stays recorded, so a later STOP can try again.
+    (0, multiplexer_1.killLaunchSession)(entry.multiplexer, entry.name, deps.run);
+    if ((0, multiplexer_1.launchSessionExists)(entry.multiplexer, entry.name, deps.run))
         return "failed";
     forget();
     return "stopped";
 }
+/** Drop one name from started.json and delete its files (settings, MCP config). */
+function forgetStarted(name, dir) {
+    const recordFile = (0, started_1.startedRecordPath)(dir);
+    (0, started_1.saveStarted)((0, started_1.loadStarted)(recordFile).filter((s) => s.name !== name), recordFile);
+    (0, approval_settings_1.removeLaunchFiles)(name, dir);
+}
+/**
+ * Forget a launch whose launcher session has ENDED on its own (the terminal closed, claude exited):
+ * drop it from started.json. One still running is never touched. True when one was forgotten.
+ * The relay calls this when a channel session it knew is found dead.
+ */
+function forgetEndedLaunch(name, deps) {
+    const entry = (0, started_1.loadStarted)((0, started_1.startedRecordPath)(deps.launchDir)).find((s) => s.name === name);
+    if (!entry || (0, multiplexer_1.launchSessionExists)(entry.multiplexer, entry.name, deps.run))
+        return false;
+    forgetStarted(name, deps.launchDir);
+    return true;
+}
+/**
+ * Forget EVERY launch whose launcher session has ended on its own — a claude killed by hand, a
+ * terminal closed — and return what was forgotten. The relay runs this on its session polls, so a
+ * dead launch does not sit in started.json until the next START happens to prune it (2026-10-16,
+ * the Mac: `qa_kill`'s tmux session ended, its channel had never registered with that relay, so
+ * the channel sweep never saw it, and it stayed listed for minutes). A session whose state cannot
+ * be read is kept: forgetting a live one would let its name be started twice.
+ */
+function forgetEndedLaunches(deps) {
+    const started = (0, started_1.loadStarted)((0, started_1.startedRecordPath)(deps.launchDir));
+    const ended = started.filter((s) => (0, multiplexer_1.launchSessionState)(s.multiplexer, s.name, deps.run) === "ended");
+    for (const gone of ended)
+        forgetStarted(gone.name, deps.launchDir);
+    return ended;
+}
 /** Forget sessions that ended on their own (and delete their settings files); return the rest. */
 function pruneEnded(started, live, deps) {
     const alive = started.filter((s) => live.includes(s.name));
     if (alive.length === started.length)
         return started;
     for (const gone of started.filter((s) => !alive.includes(s)))
-        (0, approval_settings_1.removeApprovalSettings)(gone.name, deps.launchDir);
+        (0, approval_settings_1.removeLaunchFiles)(gone.name, deps.launchDir);
     (0, started_1.saveStarted)(alive, (0, started_1.startedRecordPath)(deps.launchDir));
     return alive;
 }
@@ -302,7 +364,8 @@ function parseLaunch(raw) {
 /**
  * Which of this computer's Bay connections a launch joins on. `entry` is the MCP connection to
  * name in the `/baychat` line — undefined when there is only one, so there is nothing to choose
- * (a one-Bay computer's line stays exactly as before). Null: the launch's Bay has no connection
+ * (a one-Bay computer's line stays exactly as before). `token` is that Bay's login, for a relay
+ * that gives the session a connection of its own (relay-identity.ts); absent with no saved set. Null: the launch's Bay has no connection
  * here, and the session must not be started into some other Bay.
  *
  * The launcher runs in the DEFAULT Bay's relay, so a launch normally names that Bay; an older
@@ -316,8 +379,8 @@ function launchBayEntry(bay, bays) {
     if (!found)
         return null;
     if (bays.length < 2)
-        return { entry: undefined };
-    return { entry: found.isDefault ? bays_1.DEFAULT_MCP_ENTRY : (0, bays_1.bayEntryName)(found, bays) };
+        return { entry: undefined, token: found.token };
+    return { entry: found.isDefault ? bays_1.DEFAULT_MCP_ENTRY : (0, bays_1.bayEntryName)(found, bays), token: found.token };
 }
 /** `null` is "join nothing"; undefined is a join that is present but malformed. */
 function parseJoin(raw) {

package/dist/relay/launcher/loop.js

@@ -45,6 +45,7 @@ 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 relay_identity_1 = require("./relay-identity");
 const handle_1 = require("./handle");
 const multiplexer_1 = require("./multiplexer");
 /**
@@ -66,8 +67,8 @@ const BACKOFF_MAX_MS = 60_000;
 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, onLaunch, deps: overrides }) {
-    const deps = { ...realLoopDeps(log, signal), ...overrides };
+async function startLauncher({ auth, log, signal, onLaunch, forgetSession, deps: overrides }) {
+    const deps = { ...realLoopDeps(auth, log, signal, forgetSession), ...overrides };
     let advertised;
     let unreported;
     let backoff = BACKOFF_MIN_MS;
@@ -146,7 +147,7 @@ function idOf(raw) {
 function describe(err) {
     return err instanceof Error ? err.message : String(err);
 }
-function realLoopDeps(log, signal) {
+function realLoopDeps(auth, log, signal, forgetSession) {
     const binaryEnv = () => (0, runtime_binary_1.currentBinaryEnv)();
     const handleDeps = () => ({
         loadPolicy: () => (0, policy_1.loadLaunchPolicy)(),
@@ -166,8 +167,12 @@ function realLoopDeps(log, signal) {
         cli: (0, approval_settings_1.currentCliLaunch)(),
         launchDir: (0, approval_settings_1.launchDir)(),
         pathEnv: (0, spawn_env_1.headlessSpawnEnv)().PATH ?? "",
+        // The session talks to the same server and account as this relay (relay-identity.ts).
+        relayEnv: (0, relay_identity_1.relayIdentityEnv)(),
+        ownServer: (0, relay_identity_1.relayHasOwnSetup)() ? { baseUrl: auth.baseUrl, token: auth.token } : null,
         now: () => new Date(),
         log,
+        forgetSession,
     });
     return {
         request: exports.deviceRequest,

package/dist/relay/launcher/multiplexer.js

@@ -37,6 +37,8 @@ exports.realRun = exports.WITHHELD_FROM_AGENTS = void 0;
 exports.agentSafeEnv = agentSafeEnv;
 exports.detectMultiplexer = detectMultiplexer;
 exports.liveLaunchSessions = liveLaunchSessions;
+exports.launchSessionExists = launchSessionExists;
+exports.launchSessionState = launchSessionState;
 exports.killLaunchSession = killLaunchSession;
 exports.tmuxPaneTarget = tmuxPaneTarget;
 exports.capturePane = capturePane;
@@ -105,7 +107,36 @@ function liveLaunchSessions(multiplexer, run) {
     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. */
+/**
+ * Is the launcher session for `sessionName` still there? tmux: `has-session -t =bc-<name>` (exact
+ * name), the one question that cannot be answered by a stale listing. screen: its listing.
+ */
+function launchSessionExists(multiplexer, sessionName, run) {
+    return launchSessionState(multiplexer, sessionName, run) === "running";
+}
+/**
+ * `launchSessionExists`, for a caller that must not act on a guess: "unknown" when the
+ * multiplexer could not be asked at all (not on PATH, would not spawn), so a sweep never
+ * forgets a live session because tmux was briefly unreachable. tmux answers non-zero both for
+ * "no such session" and "no server running" — either way there is no `bc-<name>`.
+ */
+function launchSessionState(multiplexer, sessionName, run) {
+    if (multiplexer === "tmux") {
+        const res = run("tmux", ["has-session", "-t", `=${(0, argv_1.multiplexerSessionName)(sessionName)}`]);
+        if (res.error)
+            return "unknown";
+        return res.status === 0 ? "running" : "ended";
+    }
+    // `screen -ls` exits 1 even when listing, so only a failure to run it is "unknown".
+    if (run("screen", ["-ls"]).error)
+        return "unknown";
+    return liveLaunchSessions(multiplexer, run).includes(sessionName) ? "running" : "ended";
+}
+/**
+ * Kill the launcher session for `sessionName` — the WHOLE `bc-<name>` session, every window and
+ * pane in it, never just the pane or the claude process. True when the multiplexer said it did;
+ * the caller confirms it is gone (`launchSessionExists`).
+ */
 function killLaunchSession(multiplexer, sessionName, run) {
     const target = (0, argv_1.multiplexerSessionName)(sessionName);
     const res = multiplexer === "tmux"

package/dist/relay/launcher/relay-identity.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * WHICH BayChat a launched session talks to: the same one as the relay that launched it.
+ *
+ * A relay can run on a setup of its own — `BAYCHAT_CONFIG_DIR` (another login, another account)
+ * and/or `BAYCHAT_API_URL` (another server). The Claude Code it launches used to know none of
+ * it: the `env K=V … claude` exec carried only the channel marker and PATH, and Claude Code's
+ * BayChat connection is the computer's user-wide `baychat` MCP server (`claude mcp add --scope
+ * user`, the DEFAULT login). So a session launched by a test relay joined the production Bay
+ * (2026-10-16). Two halves fix it:
+ *
+ *   1. `relayIdentityEnv` — the relay's own location variables ride into the pane, so every
+ *      `baychat` the session runs (the skill, `session-name`, the approve and denied hooks, the
+ *      channel server) reads the relay's config, server and socket. NEVER a token: the `env
+ *      K=V` exec puts these in the multiplexer's argv, which any process on the machine can read.
+ *   2. `relayHasOwnSetup` — when the relay is on a setup of its own, the session also gets a
+ *      connection of its own (`--mcp-config`, approval-settings.ts `writeLaunchMcpConfig`) and
+ *      is told to join on it, never on the user-wide `baychat` that belongs to another login.
+ *
+ * A relay on the computer's ordinary setup (neither variable set — how `baychat relay` and its
+ * autostart run) launches exactly as before.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayIdentityEnv = relayIdentityEnv;
+exports.relayHasOwnSetup = relayHasOwnSetup;
+/** The variables that say where a relay's config, server, socket and mailbox are. No secrets. */
+const RELAY_LOCATION_VARS = ["BAYCHAT_CONFIG_DIR", "BAYCHAT_API_URL", "BAYCHAT_RELAY_SOCKET", "BAYCHAT_MAILBOX_DIR"];
+/** The relay's location variables that are set, to hand to a launched pane. */
+function relayIdentityEnv(env = process.env) {
+    const out = {};
+    for (const name of RELAY_LOCATION_VARS) {
+        const value = env[name];
+        if (value)
+            out[name] = value;
+    }
+    return out;
+}
+/** True when the relay runs on another login or server than the computer's default one. */
+function relayHasOwnSetup(env = process.env) {
+    return Boolean(env.BAYCHAT_CONFIG_DIR || env.BAYCHAT_API_URL);
+}

package/dist/relay/log-line.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relayLogLine = relayLogLine;
+/**
+ * One relay.log line: an ISO timestamp (UTC), the `[relay]` tag, the message. relay.log is read
+ * after the fact, against the server's own UTC log lines; without a time on each line a STOP or a
+ * registration could not be placed (2026-10-16, mac_motion).
+ */
+function relayLogLine(line, now = new Date()) {
+    return `${now.toISOString()} [relay] ${line}`;
+}

package/dist/relay/registry.js

@@ -139,6 +139,13 @@ class SessionRegistry {
     get(name) {
         return this.sessions.get(name);
     }
+    /** Forget one session outright — it was stopped, or found dead. True when it was known. */
+    remove(name) {
+        const known = this.sessions.delete(name);
+        if (known)
+            this.save();
+        return known;
+    }
     /**
      * Forget how to resume this session — what `/clear` means to the headless path.
      *