baychat 0.33.3 → 0.34.0

package/dist/relay/launcher/handle.js

@@ -9,10 +9,13 @@ exports.launchBayEntry = launchBayEntry;
 const bays_1 = require("../../bays");
 const detect_1 = require("../../channel/detect");
 const policy_1 = require("../../launch/policy");
+const acp_launch_1 = require("./acp-launch");
 const argv_1 = require("./argv");
 const approval_settings_1 = require("./approval-settings");
 const capabilities_1 = require("./capabilities");
+const codex_launch_1 = require("./codex-launch");
 const dev_channel_screen_1 = require("./dev-channel-screen");
+const stop_registered_1 = require("./stop-registered");
 const multiplexer_1 = require("./multiplexer");
 const started_1 = require("./started");
 const refused = (reason) => ({ status: "REFUSED", reason });
@@ -35,38 +38,101 @@ async function handleLaunch(launch, deps, io) {
         return refused("NAME_INVALID");
     if (launch.kind === "STOP")
         return stopSession(launch, deps);
+    if ((0, acp_launch_1.isAcpLaunchRuntime)(launch.runtime))
+        return startAcp(launch, deps);
     const started = startSession(launch, deps);
     if ("status" in started)
         return started;
-    // Monitor sessions have no channel flag, so there is no warning to wait for.
-    if (launch.listen === "monitor")
+    // Monitor sessions have no channel flag, so there is no warning to wait for; neither has Codex.
+    if (launch.listen === "monitor" || launch.runtime !== "claude")
         return { status: "STARTED" };
     return watchForDevChannelWarning(launch, started.entry, deps, io);
 }
-/** Check, spawn and record a START; the report when it ends here, else the recorded session. */
-function startSession(launch, deps) {
+/** The checks every START makes before anything runs: the spot, the runtime, the room, the folder. */
+function spotFor(launch, deps) {
     const spot = deps.loadPolicy()?.spots.find((s) => s.id === launch.spotId);
     if (!spot)
         return refused("SPOT_UNKNOWN");
     if (!(0, policy_1.isLaunchRuntime)(launch.runtime) || !spot.runtimes.includes(launch.runtime))
         return refused("RUNTIME_NOT_OFFERED");
-    if (launch.runtime !== "claude")
-        return refused("RUNTIME_NOT_YET");
     if (launch.join && "group" in launch.join && (0, argv_1.roomTitleProblem)(launch.join.group))
         return refused("ROOM_INVALID");
+    const folder = deps.resolveFolder(spot);
+    if (!folder.ok) {
+        deps.log(`launch ${launch.id}: refused, ${folder.reason}`);
+        return refused("FOLDER_CHANGED");
+    }
+    return { spot, folder: folder.path };
+}
+/** A relay-run agent (dsh, Cursor): no terminal — the daemon registers it and runs it per turn. */
+async function startAcp(launch, deps) {
+    const place = spotFor(launch, deps);
+    if ("status" in place)
+        return place;
+    if (!deps.acp || !(0, acp_launch_1.isAcpLaunchRuntime)(launch.runtime))
+        return refused("RUNTIME_NOT_YET");
+    const bays = deps.loadBays();
+    if (!launchBayEntry(launch.bay, bays))
+        return refused("BAY_NOT_CONNECTED");
+    // The relay runs, keeps alive and answers for its agents with its DEFAULT Bay's login, so an
+    // agent started into another Bay would live in the wrong one after its first join.
+    const defaultBay = bays.find((b) => b.isDefault);
+    if (launch.bay && defaultBay && launch.bay.id !== defaultBay.bayId) {
+        deps.log(`launch ${launch.id}: refused, a relay-run agent starts only in this computer's default Bay for now`);
+        return refused("OTHER_BAY_NOT_YET");
+    }
+    // The same caps as a terminal session: per computer, and per folder.
+    const multiplexer = deps.detectMultiplexer();
+    const live = multiplexer ? (0, multiplexer_1.liveLaunchSessions)(multiplexer, deps.run) : [];
+    const agents = deps.acp.running();
+    // Ended terminal sessions are cleared first, as a terminal START does, so they never count.
+    const started = multiplexer ? pruneEnded((0, started_1.loadStarted)((0, started_1.startedRecordPath)(deps.launchDir)), live, deps) : [];
+    const inFolder = started.filter((s) => s.spotId === place.spot.id).length + agents.filter((a) => a.cwd === place.folder).length;
+    if (live.length + agents.length >= policy_1.MAX_SESSIONS_PER_COMPUTER || inFolder >= place.spot.maxSessions) {
+        deps.log(`launch ${launch.id}: refused, too many sessions running (${live.length + agents.length} here, the folder "${place.spot.label}" allows ${place.spot.maxSessions})`);
+        return refused("CAP_REACHED");
+    }
+    return deps.acp.start({ launchId: launch.id, session: launch.sessionName, runtime: launch.runtime, folder: place.folder, join: launch.join });
+}
+/** Check, spawn and record a START; the report when it ends here, else the recorded session. */
+function startSession(launch, deps) {
+    const place = spotFor(launch, deps);
+    if ("status" in place)
+        return place;
+    const { spot } = place;
+    const folder = { path: place.folder };
+    const codex = launch.runtime === "codex";
+    if (!codex && launch.runtime !== "claude")
+        return refused("RUNTIME_NOT_YET");
     const bay = launchBayEntry(launch.bay, deps.loadBays());
     if (!bay) {
         deps.log(`launch ${launch.id}: refused, this computer is not logged in to the Bay "${launch.bay?.name ?? ""}". Run \`baychat login\` here.`);
         return refused("BAY_NOT_CONNECTED");
     }
-    const folder = deps.resolveFolder(spot);
-    if (!folder.ok) {
-        deps.log(`launch ${launch.id}: refused, ${folder.reason}`);
-        return refused("FOLDER_CHANGED");
+    if (codex) {
+        // Codex reads only its own config.toml: a relay on a setup of its own has no connection to
+        // give it there (a token in its argv would show in `ps`), so that case is not offered yet.
+        if (deps.ownServer) {
+            deps.log(`launch ${launch.id}: refused, Codex cannot use this relay's own connection yet`);
+            return refused("RUNTIME_NOT_YET");
+        }
+        if (!spot.unattendedCodex) {
+            deps.log(`launch ${launch.id}: refused, Codex may not start unattended in "${spot.label}". Run \`baychat launch add ${folder.path} --runtime ${spot.runtimes.join(",")} --unattended\` here to allow it.`);
+            return refused("UNATTENDED_NOT_ALLOWED");
+        }
+        if (launch.join && "group" in launch.join && !codex_launch_1.CODEX_ROOM_ID_RE.test(launch.join.group)) {
+            deps.log(`launch ${launch.id}: refused, Codex is started into an existing group only (by id)`);
+            return refused("ROOM_EXISTING_ONLY");
+        }
+        const problem = (0, codex_launch_1.codexLaunchProblem)(folder.path, () => deps.readCodexConfig?.() ?? null, bay.entry ?? bays_1.DEFAULT_MCP_ENTRY);
+        if (problem) {
+            deps.log(`launch ${launch.id}: refused, ${problem === "RUNTIME_NOT_CONNECTED" ? "Codex has no BayChat connection here. Run `baychat connect codex`." : `Codex has not trusted ${folder.path}. Open Codex there once and trust it.`}`);
+            return refused(problem);
+        }
     }
-    // An untrusted folder would leave claude waiting at "Is this a project you trust?" forever,
-    // in a detached pane nobody sees. Refuse instead, so the phone can say what to do.
-    if (!deps.isFolderTrusted(folder.path)) {
+    else if (!deps.isFolderTrusted(folder.path)) {
+        // An untrusted folder would leave claude waiting at "Is this a project you trust?" forever,
+        // in a detached pane nobody sees. Refuse instead, so the phone can say what to do.
         deps.log(`launch ${launch.id}: refused, Claude Code has not trusted ${folder.path}. Run \`baychat launch add\` for it at this computer.`);
         return refused("FOLDER_NOT_TRUSTED");
     }
@@ -87,13 +153,28 @@ function startSession(launch, deps) {
         // 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) {
+    // Relay-run agents (dsh, Cursor) count too: the caps are per computer and per folder, whatever runs.
+    const agents = deps.acp?.running() ?? [];
+    if (live.length + agents.length >= policy_1.MAX_SESSIONS_PER_COMPUTER ||
+        started.filter((s) => s.spotId === spot.id).length + agents.filter((a) => a.cwd === folder.path).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);
+    const binary = deps.resolveBinary(capabilities_1.RUNTIME_BINARY[codex ? "codex" : "claude"]);
     if (!binary.ok)
         return refused("RUNTIME_MISSING");
+    if (codex) {
+        const command = (0, argv_1.buildCodexLaunchCommand)({
+            multiplexer,
+            sessionName: launch.sessionName,
+            folder: folder.path,
+            codexBin: binary.path,
+            env: { ...(deps.relayEnv ?? {}), PATH: deps.pathEnv },
+            join: launch.join,
+            bayEntry: bay.entry,
+        });
+        return spawnRecorded(launch, deps, command, spot, multiplexer, started, recordFile, "Codex runs with --ask-for-approval never in its workspace sandbox");
+    }
     // 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);
     // A relay on a setup of its own gives the session its own connection to the relay's server,
@@ -120,6 +201,11 @@ function startSession(launch, deps) {
         join: launch.join,
         bayEntry,
     });
+    return spawnRecorded(launch, deps, command, spot, multiplexer, started, recordFile, "Approvals for this session come to BayChat");
+}
+/** Run the multiplexer command and record the session BEFORE any watching, so a STOP (the
+ *  owner's Deny, or Stop) can always find it. */
+function spawnRecorded(launch, deps, command, spot, multiplexer, started, recordFile, note) {
     const res = deps.run(command.file, command.args, { cwd: command.cwd, env: command.env });
     if (res.error || res.status !== 0) {
         (0, approval_settings_1.removeLaunchFiles)(launch.sessionName, deps.launchDir);
@@ -127,9 +213,8 @@ function startSession(launch, deps) {
         return { status: "FAILED", reason: "SPAWN_FAILED" };
     }
     const entry = { name: launch.sessionName, spotId: spot.id, runtime: launch.runtime, multiplexer, launchId: launch.id, startedAt: deps.now().toISOString() };
-    // Recorded BEFORE any watching, so a STOP (the owner's Deny, or Stop) can always find it.
     (0, started_1.saveStarted)([...started, entry], recordFile);
-    deps.log(`launch ${launch.id}: started "${launch.sessionName}" in "${spot.label}" (${launch.listen}) for ${launch.requestedBy.name}. Approvals for this session come to BayChat.`);
+    deps.log(`launch ${launch.id}: started "${launch.sessionName}" (${launch.runtime}) in "${spot.label}" (${launch.listen}) for ${launch.requestedBy.name}. ${note}.`);
     return { entry };
 }
 /**
@@ -245,12 +330,18 @@ function stopOwn(launch, entry, deps, report, why) {
  * STOP kills only what the launcher itself started: the session must be in started.json AND
  * alive. A hand-made `bc-x` tmux session, or one listed but already gone, is never touched.
  */
-function stopSession(launch, deps) {
+async function stopSession(launch, deps) {
     const recordFile = (0, started_1.startedRecordPath)(deps.launchDir);
     const started = (0, started_1.loadStarted)(recordFile);
     const entry = started.find((s) => s.name === launch.sessionName);
-    if (!entry)
-        return refused("NOT_LAUNCHED");
+    if (!entry) {
+        // A relay-run agent (dsh, Cursor) has no terminal: End is the relay no longer running it.
+        if (deps.acp?.stop(launch.sessionName)) {
+            deps.forgetSession?.(launch.sessionName);
+            return { status: "STARTED" };
+        }
+        return launch.scope === "any" ? await stopRegisteredSession(launch, deps) : refused("NOT_LAUNCHED");
+    }
     const outcome = stopRecorded(entry, deps);
     if (outcome === "not-running") {
         deps.log(`launch ${launch.id}: "${entry.name}" was not running any more; its records are cleared`);
@@ -263,6 +354,28 @@ function stopSession(launch, deps) {
     deps.log(`launch ${launch.id}: stopped "${entry.name}" for ${launch.requestedBy.name} — its ${entry.multiplexer} session is gone (checked)`);
     return { status: "STARTED" };
 }
+/** A scope "any" STOP for a session the launcher did not start: its registered pane, checked. */
+async function stopRegisteredSession(launch, deps) {
+    if (!deps.registeredSession || !deps.stopRegisteredDeps)
+        return refused("NOT_LAUNCHED");
+    const name = launch.sessionName;
+    const outcome = await (0, stop_registered_1.stopRegistered)(name, deps.registeredSession(name), deps.stopRegisteredDeps);
+    switch (outcome) {
+        case "stopped":
+            deps.forgetSession?.(name);
+            deps.log(`launch ${launch.id}: closed "${name}" for ${launch.requestedBy.name} (End in BayChat)`);
+            return { status: "STARTED" };
+        case "not-running":
+            deps.forgetSession?.(name);
+            return refused("NOT_RUNNING");
+        case "not-ours":
+            return refused("NOT_OURS");
+        case "not-registered":
+            return refused("NOT_REGISTERED");
+        default:
+            return { status: "FAILED", reason: "STOP_FAILED" };
+    }
+}
 /**
  * The one stop routine (STOP, and a launch abandoned while watching its pane): kill the recorded
  * session if it is alive, then forget it and delete its settings file. A kill that fails leaves
@@ -359,6 +472,8 @@ function parseLaunch(raw) {
         ...parseBay(l.bay),
         // Only an explicit `true` authorises; a missing or odd value is a refusal.
         commandAuthorized: l.commandAuthorized === true,
+        // Only an explicit "any" on a STOP widens it; anything else is the launcher's own sessions.
+        ...(l.kind === "STOP" && l.scope === "any" ? { scope: "any" } : {}),
     };
 }
 /**

package/dist/relay/launcher/loop.js

@@ -45,7 +45,10 @@ 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 codex_launch_1 = require("./codex-launch");
 const relay_identity_1 = require("./relay-identity");
+const session_spots_1 = require("./session-spots");
+const stop_registered_1 = require("./stop-registered");
 const handle_1 = require("./handle");
 const multiplexer_1 = require("./multiplexer");
 /**
@@ -67,9 +70,13 @@ 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, forgetSession, deps: overrides }) {
-    const deps = { ...realLoopDeps(auth, log, signal, forgetSession), ...overrides };
+async function startLauncher(opts) {
+    const { auth, log, signal, onLaunch, deps: overrides } = opts;
+    const deps = { ...realLoopDeps(auth, log, signal, opts), ...overrides };
     let advertised;
+    // What was last reported to PUT /launch-sessions; `false` once the server said it has no such
+    // route (an older server), so it is not asked again until the relay restarts.
+    let reportedSpots;
     let unreported;
     let backoff = BACKOFF_MIN_MS;
     while (!signal.aborted) {
@@ -84,6 +91,7 @@ async function startLauncher({ auth, log, signal, onLaunch, forgetSession, deps:
                 await deps.request(auth, "PUT", "/api/device-api/launch-capabilities", deps.capabilities(), signal);
                 advertised = { stamp, at: deps.now() };
             }
+            reportedSpots = await reportSessionSpots(deps, auth, signal, reportedSpots, log);
             const answer = (await deps.request(auth, "GET", `/api/device-api/launches/next?wait=${WAIT_SECONDS}`, undefined, signal));
             const raw = answer?.launch;
             if (raw) {
@@ -113,6 +121,32 @@ async function startLauncher({ auth, log, signal, onLaunch, forgetSession, deps:
         }
     }
 }
+/**
+ * Send the sessions' launch spots when they changed since the last report. Never fails the loop:
+ * "Start again" is a convenience, and launching must go on without it.
+ */
+async function reportSessionSpots(deps, auth, signal, last, log) {
+    if (last === false || !deps.sessionSpots)
+        return last;
+    const sessions = deps.sessionSpots();
+    const key = JSON.stringify(sessions);
+    if (key === last)
+        return last;
+    try {
+        await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions }, signal);
+        return key;
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError && err.status === 404)
+            return false;
+        log(`launcher: could not report the sessions' folders (${describe(err)})`);
+        // Refused as it is (a 4xx: say, a runtime this server does not know yet): sending the same
+        // report again every poll would only be refused again. It goes again once it changes.
+        if (err instanceof api_1.ApiError && err.status >= 400 && err.status < 500)
+            return key;
+        return last;
+    }
+}
 /** A bug in handling one launch must report FAILED, not spin the loop on the same launch. */
 async function safeHandle(deps, launch, io, log) {
     try {
@@ -147,7 +181,7 @@ function idOf(raw) {
 function describe(err) {
     return err instanceof Error ? err.message : String(err);
 }
-function realLoopDeps(auth, log, signal, forgetSession) {
+function realLoopDeps(auth, log, signal, { forgetSession, registeredSession, registeredSessions, acp }) {
     const binaryEnv = () => (0, runtime_binary_1.currentBinaryEnv)();
     const handleDeps = () => ({
         loadPolicy: () => (0, policy_1.loadLaunchPolicy)(),
@@ -173,6 +207,10 @@ function realLoopDeps(auth, log, signal, forgetSession) {
         now: () => new Date(),
         log,
         forgetSession,
+        registeredSession,
+        stopRegisteredDeps: (0, stop_registered_1.realStopRegisteredDeps)(multiplexer_1.realRun, log),
+        readCodexConfig: () => (0, codex_launch_1.readCodexConfig)(),
+        acp,
     });
     return {
         request: exports.deviceRequest,
@@ -192,6 +230,11 @@ function realLoopDeps(auth, log, signal, forgetSession) {
         handle: (launch, io) => (0, handle_1.handleLaunch)(launch, handleDeps(), io),
         sleep: sleepUnlessAborted,
         now: () => Date.now(),
+        ...(registeredSessions
+            ? {
+                sessionSpots: () => (0, session_spots_1.sessionSpots)(registeredSessions(), (0, policy_1.loadLaunchPolicy)(), { resolveFolder: policy_1.resolveSpotFolder, realpath: session_spots_1.realRealpath }),
+            }
+            : {}),
     };
 }
 /**

package/dist/relay/launcher/multiplexer.js

@@ -39,6 +39,8 @@ exports.detectMultiplexer = detectMultiplexer;
 exports.liveLaunchSessions = liveLaunchSessions;
 exports.launchSessionExists = launchSessionExists;
 exports.launchSessionState = launchSessionState;
+exports.defaultTmuxSocket = defaultTmuxSocket;
+exports.healTmuxSocket = healTmuxSocket;
 exports.killLaunchSession = killLaunchSession;
 exports.tmuxPaneTarget = tmuxPaneTarget;
 exports.capturePane = capturePane;
@@ -120,11 +122,21 @@ function launchSessionExists(multiplexer, sessionName, run) {
  * 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) {
+function launchSessionState(multiplexer, sessionName, run, heal = healTmuxSocket) {
     if (multiplexer === "tmux") {
-        const res = run("tmux", ["has-session", "-t", `=${(0, argv_1.multiplexerSessionName)(sessionName)}`]);
+        const ask = () => run("tmux", ["has-session", "-t", `=${(0, argv_1.multiplexerSessionName)(sessionName)}`]);
+        let res = ask();
         if (res.error)
             return "unknown";
+        // The socket gone under a live server reads exactly like "no session" — and on 2026-10-22 it
+        // made the relay forget every launch (started.json emptied), so End could close none of them.
+        if (res.status !== 0 && SOCKET_UNREACHABLE.test(res.stderr)) {
+            const healed = heal(run);
+            if (healed === "failed" || healed === "signalled")
+                return "unknown";
+            if (healed === "healed")
+                res = ask();
+        }
         return res.status === 0 ? "running" : "ended";
     }
     // `screen -ls` exits 1 even when listing, so only a failure to run it is "unknown".
@@ -132,6 +144,69 @@ function launchSessionState(multiplexer, sessionName, run) {
         return "unknown";
     return liveLaunchSessions(multiplexer, run).includes(sessionName) ? "running" : "ended";
 }
+/** tmux's answer when it cannot reach a server through the socket file (as opposed to "can't find
+ *  session" from a server that answered). "no server running" is the same thing when the socket's
+ *  directory survived but the file did not. */
+const SOCKET_UNREACHABLE = /error connecting to|no server running/i;
+const realHealOps = {
+    exists: (file) => fs.existsSync(file),
+    mkdir: (dir) => fs.mkdirSync(dir, { recursive: true, mode: 0o700 }),
+    signal: (pid) => process.kill(pid, "SIGUSR1"),
+};
+/** The default tmux server's socket for this user: `$TMUX_TMPDIR` (else /tmp) + `tmux-<uid>/default`. */
+function defaultTmuxSocket(env = process.env, uid = process.getuid?.() ?? 0) {
+    return path.join(env.TMUX_TMPDIR || "/tmp", `tmux-${uid}`, "default");
+}
+/**
+ * Make a tmux server's socket again when it was deleted under the running server. macOS's daily
+ * cleanup removes what under /private/tmp has not been touched for days (the Mac mini,
+ * 2026-10-22: `tmux-502/` gone, the server alive with every session, and every tmux command
+ * "error connecting"). tmux's documented cure is SIGUSR1 to the SERVER, which recreates its socket.
+ *
+ * Only a server is signalled, never a client (SIGUSR1 would end a client, detaching someone's
+ * terminal): the pid the session recorded from `$TMUX` when given, else this user's `tmux`
+ * processes whose parent is pid 1 — a tmux server daemonizes, a client keeps its shell as parent.
+ * Never waits (the relay is one thread): a socket not back yet is `signalled`, and the caller looks
+ * again later — a sweep reads "unknown" meanwhile, a STOP waits for it asynchronously.
+ */
+function healTmuxSocket(run, opts = {}, ops = realHealOps) {
+    const socket = opts.socket ?? defaultTmuxSocket(process.env, opts.uid);
+    if (ops.exists(socket))
+        return "present";
+    const servers = opts.serverPid ? [opts.serverPid].filter((pid) => isTmuxProcess(pid, run)) : tmuxServers(run, opts.uid);
+    if (servers.length === 0)
+        return "no-server";
+    try {
+        ops.mkdir(path.dirname(socket));
+        for (const pid of servers)
+            ops.signal(pid);
+    }
+    catch {
+        return "failed";
+    }
+    return ops.exists(socket) ? "healed" : "signalled";
+}
+/** tmux's own process name: `tmux` (macOS `ps` may print its full path), or on Linux the server's
+ *  `tmux: server` / a client's `tmux: client`. Never a lookalike such as `tmuxinator`. */
+function isTmuxName(comm) {
+    return /^tmux(:|$)/.test(path.basename(comm.trim()));
+}
+function isTmuxProcess(pid, run) {
+    const res = run("ps", ["-p", String(pid), "-o", "comm="]);
+    return !res.error && res.status === 0 && isTmuxName(res.stdout);
+}
+/** This user's tmux SERVERS: `tmux` processes whose parent is pid 1. */
+function tmuxServers(run, uid = process.getuid?.() ?? 0) {
+    const res = run("ps", ["-U", String(uid), "-o", "pid=,ppid=,comm="]);
+    if (res.error || res.status !== 0)
+        return [];
+    return res.stdout
+        .split("\n")
+        .map((line) => line.trim().split(/\s+/))
+        .filter(([, ppid, comm]) => ppid === "1" && !!comm && isTmuxName(comm))
+        .map(([pid]) => Number(pid))
+        .filter((pid) => Number.isInteger(pid) && pid > 0);
+}
 /**
  * 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;

package/dist/relay/launcher/session-spots.js

@@ -0,0 +1,73 @@
+"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.MAX_SESSION_SPOTS = void 0;
+exports.sessionSpots = sessionSpots;
+exports.realRealpath = realRealpath;
+const fs = __importStar(require("fs"));
+const policy_1 = require("../../launch/policy");
+const argv_1 = require("./argv");
+/** The server takes at most this many per report. */
+exports.MAX_SESSION_SPOTS = 50;
+function sessionSpots(sessions, policy, deps) {
+    const folders = (policy?.spots ?? []).flatMap((spot) => {
+        const folder = deps.resolveFolder(spot);
+        return folder.ok ? [{ spot, path: folder.path }] : [];
+    });
+    const out = [];
+    for (const session of sessions) {
+        if ((0, argv_1.launchNameProblem)(session.name) || !(0, policy_1.isLaunchRuntime)(session.runtime))
+            continue;
+        // Where it runs is unknown (a registration older than this): say nothing about it.
+        const dir = session.resumeCwd ?? session.cwd;
+        if (!dir)
+            continue;
+        const real = deps.realpath(dir);
+        const runtime = session.runtime;
+        const match = real ? folders.find((f) => f.path === real && f.spot.runtimes.includes(runtime)) : undefined;
+        out.push({ name: session.name, spotId: match?.spot.id ?? null, runtime, listen: session.delivery === "channel" ? "channel" : "monitor" });
+        if (out.length === exports.MAX_SESSION_SPOTS)
+            break;
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function realRealpath(dir) {
+    try {
+        return fs.realpathSync(dir);
+    }
+    catch {
+        return null;
+    }
+}