baychat 0.34.0 → 0.34.2

package/dist/relay/launcher/handle.js

@@ -14,6 +14,7 @@ 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 codex_version_1 = require("../codex-version");
 const dev_channel_screen_1 = require("./dev-channel-screen");
 const stop_registered_1 = require("./stop-registered");
 const multiplexer_1 = require("./multiplexer");
@@ -40,6 +41,15 @@ async function handleLaunch(launch, deps, io) {
         return stopSession(launch, deps);
     if ((0, acp_launch_1.isAcpLaunchRuntime)(launch.runtime))
         return startAcp(launch, deps);
+    if (launch.runtime === "codex" && deps.codex && (0, codex_version_1.codexExecFallback)() && inDefaultBay(launch, deps)) {
+        // BAYCHAT_CODEX_TRANSPORT=exec: its turns run `--ask-for-approval never`, which also blocks
+        // Codex's own BayChat replies — a session started from the phone would never answer. Refused
+        // instead of started silent (2026-10-23); a Codex at this keyboard works as before.
+        deps.log(`launch ${launch.id}: refused, Codex is in fallback mode here (BAYCHAT_CODEX_TRANSPORT=exec) and could not answer in BayChat`);
+        return refused("RUNTIME_FALLBACK_MODE");
+    }
+    if (launch.runtime === "codex" && relayRunsCodex(launch, deps))
+        return startCodexRelay(launch, deps);
     const started = startSession(launch, deps);
     if ("status" in started)
         return started;
@@ -64,6 +74,77 @@ function spotFor(launch, deps) {
     }
     return { spot, folder: folder.path };
 }
+/**
+ * Sessions the relay runs itself (dsh, Cursor, Codex over app-server) and the terminal sessions
+ * the launcher sees, for the caps — a relay-run Codex's log viewer is a `bc-<name>` tmux session
+ * too, and must not be counted twice.
+ */
+function sessionsForCaps(live, deps) {
+    const relayRun = [...(deps.acp?.running() ?? []), ...(deps.codex?.running() ?? [])];
+    const names = new Set(relayRun.map((a) => a.name));
+    return { terminals: live.filter((name) => !names.has(name)), relayRun };
+}
+/** A Codex launch is run by the relay when the daemon offers that, and the launch is in its default Bay. */
+function relayRunsCodex(launch, deps) {
+    if (!deps.codex || (0, codex_version_1.codexExecFallback)())
+        return false;
+    return inDefaultBay(launch, deps);
+}
+/**
+ * The relay runs, keeps alive and asks cards for its sessions with its DEFAULT Bay's login; a
+ * Codex launched into another Bay keeps the terminal launch, which joins with that Bay's entry.
+ */
+function inDefaultBay(launch, deps) {
+    const defaultBay = deps.loadBays().find((b) => b.isDefault);
+    return !launch.bay || !defaultBay || launch.bay.id === defaultBay.bayId;
+}
+/** The checks a Codex START makes, whoever runs it; undefined when it may start. */
+function codexRefusal(launch, deps, spot, folder, entry) {
+    // 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} --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, () => deps.readCodexConfig?.() ?? null, 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}. Open Codex there once and trust it.`}`);
+        return refused(problem);
+    }
+    return undefined;
+}
+/** Codex run by the relay (codex-relay-launch.ts): the same checks and caps, no terminal of its own. */
+async function startCodexRelay(launch, deps) {
+    const place = spotFor(launch, deps);
+    if ("status" in place)
+        return place;
+    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 problem = codexRefusal(launch, deps, place.spot, place.folder, bay.entry);
+    if (problem)
+        return problem;
+    const multiplexer = deps.detectMultiplexer();
+    const live = multiplexer ? (0, multiplexer_1.liveLaunchSessions)(multiplexer, deps.run) : [];
+    const { terminals, relayRun } = sessionsForCaps(live, deps);
+    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 + relayRun.filter((a) => a.cwd === place.folder).length;
+    if (terminals.length + relayRun.length >= policy_1.MAX_SESSIONS_PER_COMPUTER || inFolder >= place.spot.maxSessions) {
+        deps.log(`launch ${launch.id}: refused, too many sessions running (${terminals.length + relayRun.length} here, the folder "${place.spot.label}" allows ${place.spot.maxSessions})`);
+        return refused("CAP_REACHED");
+    }
+    return deps.codex.start({ launchId: launch.id, session: launch.sessionName, folder: place.folder, join: launch.join });
+}
 /** 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);
@@ -84,12 +165,12 @@ async function startAcp(launch, deps) {
     // 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();
+    const { terminals, relayRun: agents } = sessionsForCaps(live, deps);
     // 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})`);
+    if (terminals.length + agents.length >= policy_1.MAX_SESSIONS_PER_COMPUTER || inFolder >= place.spot.maxSessions) {
+        deps.log(`launch ${launch.id}: refused, too many sessions running (${terminals.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 });
@@ -110,25 +191,9 @@ function startSession(launch, deps) {
         return refused("BAY_NOT_CONNECTED");
     }
     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);
-        }
+        const problem = codexRefusal(launch, deps, spot, folder.path, bay.entry);
+        if (problem)
+            return problem;
     }
     else if (!deps.isFolderTrusted(folder.path)) {
         // An untrusted folder would leave claude waiting at "Is this a project you trust?" forever,
@@ -153,9 +218,9 @@ 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");
     }
-    // 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 ||
+    // Relay-run agents (dsh, Cursor, Codex) count too: the caps are per computer and per folder, whatever runs.
+    const { terminals, relayRun: agents } = sessionsForCaps(live, deps);
+    if (terminals.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");
@@ -336,11 +401,11 @@ async function stopSession(launch, deps) {
     const entry = started.find((s) => s.name === launch.sessionName);
     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)) {
+        if (deps.acp?.stop(launch.sessionName) || deps.codex?.stop(launch.sessionName)) {
             deps.forgetSession?.(launch.sessionName);
             return { status: "STARTED" };
         }
-        return launch.scope === "any" ? await stopRegisteredSession(launch, deps) : refused("NOT_LAUNCHED");
+        return launch.scope === "any" ? await stopRegisteredSession(launch, deps, started) : refused("NOT_LAUNCHED");
     }
     const outcome = stopRecorded(entry, deps);
     if (outcome === "not-running") {
@@ -354,12 +419,18 @@ async 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) {
+/**
+ * A scope "any" STOP for a session the launcher did not start under that name: its registered
+ * pane, checked. `started` names the tmux sessions the launcher did start, so a session that joined
+ * under another name than its launch (B4, 2026-10-24) is still recognised as ours; a launch record
+ * left behind by the close is swept on the next poll (`forgetEndedLaunches`).
+ */
+async function stopRegisteredSession(launch, deps, started) {
     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);
+    const launched = new Set(started.filter((s) => s.multiplexer === "tmux").map((s) => (0, argv_1.multiplexerSessionName)(s.name)));
+    const outcome = await (0, stop_registered_1.stopRegistered)(name, deps.registeredSession(name), deps.stopRegisteredDeps, launched);
     switch (outcome) {
         case "stopped":
             deps.forgetSession?.(name);

package/dist/relay/launcher/loop.js

@@ -181,7 +181,7 @@ function idOf(raw) {
 function describe(err) {
     return err instanceof Error ? err.message : String(err);
 }
-function realLoopDeps(auth, log, signal, { forgetSession, registeredSession, registeredSessions, acp }) {
+function realLoopDeps(auth, log, signal, { forgetSession, registeredSession, registeredSessions, acp, codex }) {
     const binaryEnv = () => (0, runtime_binary_1.currentBinaryEnv)();
     const handleDeps = () => ({
         loadPolicy: () => (0, policy_1.loadLaunchPolicy)(),
@@ -211,6 +211,7 @@ function realLoopDeps(auth, log, signal, { forgetSession, registeredSession, reg
         stopRegisteredDeps: (0, stop_registered_1.realStopRegisteredDeps)(multiplexer_1.realRun, log),
         readCodexConfig: () => (0, codex_launch_1.readCodexConfig)(),
         acp,
+        codex,
     });
     return {
         request: exports.deviceRequest,
@@ -226,6 +227,9 @@ function realLoopDeps(auth, log, signal, { forgetSession, registeredSession, reg
         capabilities: () => (0, capabilities_1.buildCapabilities)((0, policy_1.loadLaunchPolicy)(), {
             resolveBinary: (name) => (0, runtime_binary_1.resolveRuntimeBinary)(name, binaryEnv()),
             multiplexer: (0, multiplexer_1.detectMultiplexer)(multiplexer_1.realRun),
+            // Never silent (2026-10-24): a folder that cannot start is a line in the relay's log, at
+            // every capabilities refresh, until it can.
+            onUnavailable: (spot, detail) => log(`launcher: spot "${spot.label}" left out: ${spot.runtime} ${spot.reason === "RUNTIME_BROKEN" ? "does not start" : "not found"} for the relay${detail ? ` (${detail})` : ""} — run \`baychat doctor\``),
         }),
         handle: (launch, io) => (0, handle_1.handleLaunch)(launch, handleDeps(), io),
         sleep: sleepUnlessAborted,

package/dist/relay/launcher/stop-registered.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.elapsedSeconds = elapsedSeconds;
 exports.ownSessionName = ownSessionName;
 exports.stopRegistered = stopRegistered;
 exports.realStopRegisteredDeps = realStopRegisteredDeps;
@@ -41,6 +42,79 @@ const fs = __importStar(require("fs"));
 const terminal_pane_1 = require("../terminal-pane");
 const argv_1 = require("./argv");
 const multiplexer_1 = require("./multiplexer");
+/** `ps -o etime=` has whole seconds; the agent always starts before it registers, so this is slack, not a window. */
+const START_SLACK_MS = 2_000;
+/** `ps -o etime=`: `[[dd-]hh:]mm:ss`, the same on macOS and Linux and in every locale (`lstart`
+ *  is not: "Sat 24 Oct" here, "Sa 24 Okt" on a German system). Seconds, or NaN. */
+function elapsedSeconds(etime) {
+    const m = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/.exec(etime.trim());
+    if (!m)
+        return NaN;
+    const [, days = "0", hours = "0", minutes, seconds] = m;
+    return ((Number(days) * 24 + Number(hours)) * 60 + Number(minutes)) * 60 + Number(seconds);
+}
+/**
+ * Is `pid` the process the session registered, and not a later one that reuses its number? Its
+ * start (now minus `ps -o etime=`) must not be after the registration.
+ */
+function startedBeforeRegistration(pid, registeredAt, deps) {
+    const registered = registeredAt ? Date.parse(registeredAt) : NaN;
+    if (Number.isNaN(registered))
+        return false;
+    let elapsed;
+    try {
+        elapsed = elapsedSeconds(deps.check("ps", ["-o", "etime=", "-p", String(pid)]));
+    }
+    catch {
+        return false;
+    }
+    return !Number.isNaN(elapsed) && deps.now() - elapsed * 1000 <= registered + START_SLACK_MS;
+}
+/** How long a SIGTERMed agent gets to exit before End says it could not (Claude Code quits in < 1 s). */
+const AGENT_EXIT_WAIT_MS = 5_000;
+const AGENT_EXIT_POLL_MS = 100;
+/**
+ * Ask the session's own agent process to quit (SIGTERM, never SIGKILL: it saves its state), and
+ * wait for it to be gone. The caller has already proven `pid` is that session's runtime.
+ */
+async function endAgent(name, target, deps) {
+    const pid = target.ownerPid;
+    if (deps.platform === "win32") {
+        deps.log(`stop "${name}": ending its process is not done on Windows (it would be killed, not asked to quit); left running`);
+        return "not-ours";
+    }
+    if (!startedBeforeRegistration(pid, target.registeredAt, deps)) {
+        deps.log(`stop "${name}": process ${pid} cannot be shown to be the one that registered (started later, or no registration time); left running`);
+        return "not-ours";
+    }
+    try {
+        deps.signal(pid);
+    }
+    catch (err) {
+        deps.log(`stop "${name}": could not signal its process ${pid} (${err instanceof Error ? err.message : String(err)})`);
+        return "failed";
+    }
+    for (let waited = 0; deps.alive(pid); waited += AGENT_EXIT_POLL_MS) {
+        if (waited >= AGENT_EXIT_WAIT_MS) {
+            deps.log(`stop "${name}": its process ${pid} did not quit after SIGTERM; left running`);
+            return "failed";
+        }
+        await deps.sleep(AGENT_EXIT_POLL_MS);
+    }
+    deps.log(`stop "${name}": ended its agent process ${pid}; the terminal stays open`);
+    return "stopped";
+}
+/** No terminal BayChat may close (no pane we can name): end the registered agent if it is still that runtime. */
+async function endAgentWithoutPane(name, target, deps) {
+    if (target.ownerPid === undefined)
+        return "not-ours";
+    const running = (0, terminal_pane_1.runtimeStillRunning)(target.ownerPid, target.runtime, deps.check);
+    if (!running.ok) {
+        deps.log(`stop "${name}": ${running.reason} Left alone.`);
+        return "not-ours";
+    }
+    return endAgent(name, target, deps);
+}
 /**
  * The tmux session names our CLI has ever given, for session `name` (git history of
  * multiplexer-launch.ts and launcher/argv.ts):
@@ -71,6 +145,22 @@ function lookPane(handle, run) {
     const [paneId = "", session = "", panes = "", windows = "", pid = "", tty = ""] = res.stdout.trim().split("\t");
     return { found: { paneId, session, windowPanes: Number(panes), sessionWindows: Number(windows), serverPid: Number(pid), tty } };
 }
+/**
+ * Is the pane gone after a kill? Asked as "is its id in the server's pane list", never through
+ * `display-message -t <pane>`: measured 2026-10-24 on real tmux, that answers status 0 with an
+ * empty line for a killed pane while other sessions remain, and "no server running" once the
+ * killed session was the server's last (the server exits) — both read as "still there", so a
+ * terminal that DID close was reported STOP_FAILED. The server answered a moment ago, so "no
+ * server" now means it exited with its last session.
+ */
+function paneGone(handle, run) {
+    const res = run("tmux", ["-S", handle.socket, "list-panes", "-a", "-F", "#{pane_id}"]);
+    if (res.error)
+        return false;
+    if (res.status !== 0)
+        return /no server running|error connecting/i.test(res.stderr);
+    return !res.stdout.split("\n").some((id) => id.trim() === handle.pane);
+}
 /** `lookPane`, after making the server's socket again when macOS's tmp cleanup deleted it
  *  (multiplexer.ts `healTmuxSocket`): without that, a live pane would read as unreachable. */
 async function lookPaneHealing(handle, deps) {
@@ -100,13 +190,20 @@ function aliveOn(pid, tty, check) {
         return false;
     }
 }
-async function stopRegistered(name, target, deps) {
-    if (!target?.pane)
+/**
+ * @param launched the tmux sessions the relay's launcher itself started (`bc-<launch name>`, from
+ *   started.json): a registered pane in one of them is ours whatever name the session joined under.
+ */
+async function stopRegistered(name, target, deps, launched = new Set()) {
+    if (!target)
         return "not-registered";
+    if (!target.pane)
+        return target.ownerPid === undefined ? "not-registered" : endAgentWithoutPane(name, target, deps);
     const handle = target.pane;
-    // screen and zellij cannot name the session a window is in, so check 2 is impossible: refused.
+    // screen and zellij cannot name the session a window is in, so check 2 is impossible: the
+    // terminal is never closed, only the agent itself ended.
     if (handle.kind !== "tmux")
-        return "not-ours";
+        return endAgentWithoutPane(name, target, deps);
     // Without the server's pid a pane id proves nothing (it may be a reused %N): refused.
     if (!handle.serverPid)
         return "not-ours";
@@ -122,10 +219,7 @@ async function stopRegistered(name, target, deps) {
         deps.log(`stop "${name}": pane ${handle.pane} now belongs to another tmux server; left open`);
         return "not-ours";
     }
-    if (!ownSessionName(pane.session, name, handle.session)) {
-        deps.log(`stop "${name}": pane ${handle.pane} is in tmux session "${pane.session}", which BayChat did not make; left open`);
-        return "not-ours";
-    }
+    const ours = ownSessionName(pane.session, name, handle.session) || launched.has(pane.session);
     const running = (0, terminal_pane_1.verifyPane)(handle, target.runtime, deps.check, target.ownerPid);
     if (!running.ok) {
         deps.log(`stop "${name}": ${running.reason} Left open.`);
@@ -135,10 +229,18 @@ async function stopRegistered(name, target, deps) {
         deps.log(`stop "${name}": its process ${target.ownerPid} is not on pane ${handle.pane} any more; left open`);
         return "not-ours";
     }
+    if (!ours) {
+        // The person's own tmux session: never closed. Its agent, proven on that pane, is ended.
+        if (target.ownerPid === undefined) {
+            deps.log(`stop "${name}": pane ${handle.pane} is in tmux session "${pane.session}", which BayChat did not make, and the session recorded no process to end; left open`);
+            return "not-ours";
+        }
+        return endAgent(name, target, deps);
+    }
     const whole = pane.windowPanes === 1 && pane.sessionWindows === 1;
     deps.run("tmux", whole ? ["-S", handle.socket, "kill-session", "-t", `=${pane.session}`] : ["-S", handle.socket, "kill-pane", "-t", handle.pane]);
     // The kill's own answer is not the proof (handle.ts `stopRecorded`): the pane must be GONE.
-    if (!("gone" in lookPane(handle, deps.run)))
+    if (!paneGone(handle, deps.run))
         return "failed";
     deps.log(`stop "${name}": closed ${whole ? `tmux session "${pane.session}"` : `pane ${handle.pane} of "${pane.session}"`}`);
     return "stopped";
@@ -151,5 +253,18 @@ function realStopRegisteredDeps(run, log) {
         socketExists: (socket) => fs.existsSync(socket),
         sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
         log,
+        platform: process.platform,
+        now: () => Date.now(),
+        signal: (pid) => process.kill(pid, "SIGTERM"),
+        alive: (pid) => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch (err) {
+                // EPERM: it exists, it is just not ours to signal.
+                return err.code === "EPERM";
+            }
+        },
     };
 }

package/dist/relay/registry.js

@@ -56,6 +56,12 @@ function registryPath() {
 class SessionRegistry {
     filePath;
     sessions = new Map();
+    /**
+     * Told whenever what was known about a session stops being true — it is removed, replaced,
+     * pruned, or its conversation is forgotten (`clearResume`, a relay-run Codex losing its thread).
+     * The daemon forgets that session's "Allow for this session" answers here (codex-allowances.ts).
+     */
+    onForget;
     constructor(filePath = registryPath()) {
         this.filePath = filePath;
     }
@@ -118,6 +124,7 @@ class SessionRegistry {
     replace(target) {
         const fresh = { ...stripUndefined(target), name: target.name, runtime: target.runtime, registeredAt: new Date().toISOString() };
         this.sessions.set(target.name, fresh);
+        this.onForget?.(target.name);
         this.save();
         return fresh;
     }
@@ -144,6 +151,7 @@ class SessionRegistry {
         const known = this.sessions.delete(name);
         if (known)
             this.save();
+        this.onForget?.(name);
         return known;
     }
     /**
@@ -167,6 +175,7 @@ class SessionRegistry {
         delete existing.resumeSource;
         delete existing.resumeEvidence;
         this.save();
+        this.onForget?.(name);
     }
     all() {
         return [...this.sessions.values()];
@@ -209,6 +218,7 @@ class SessionRegistry {
             if (!live.has(name) && !target.attached && !target.relayOwned) {
                 this.sessions.delete(name);
                 dropped.push(name);
+                this.onForget?.(name);
             }
         }
         if (dropped.length > 0)
@@ -226,6 +236,26 @@ class SessionRegistry {
             t.acp.sessionId = sessionId;
         this.save();
     }
+    /**
+     * Record (or, with `undefined`, forget) a relay-run Codex session's thread. A different thread
+     * is a new conversation, so it is not primed until a turn completes on it.
+     */
+    setCodexThread(name, threadId, primed = false) {
+        const t = this.sessions.get(name);
+        if (!t?.codex)
+            return;
+        if (threadId === undefined) {
+            delete t.codex.threadId;
+            this.onForget?.(name);
+        }
+        else
+            t.codex.threadId = threadId;
+        if (primed)
+            t.codex.primed = true;
+        else
+            delete t.codex.primed;
+        this.save();
+    }
     setAcpMode(name, mode) {
         const t = this.sessions.get(name);
         if (!t?.acp)

package/dist/relay/runtime-limits.js

@@ -0,0 +1,167 @@
+"use strict";
+// A terminal session's plan limits and running cost, sent to BayChat (TERMINAL_CREDITS.md):
+// `POST /api/device-api/session-limits`. Only the session's own person ever sees the percentages;
+// the cost is the runtime's own estimate (for a Pro/Max plan the subscription is a fixed price).
+//
+//   Claude Code   from its status-line JSON (claude-context.ts notes it, claude-context-flush.ts
+//                 sends it): `rate_limits.five_hour` / `seven_day` {used_percentage, resets_at}
+//                 and, where it is there, `cost.total_cost_usd`.
+//   Codex         from `codex app-server` (`readCodexRateLimits`, codex-app-server.ts) every
+//                 10 minutes, for each Codex session this relay hosts — `CodexLimitsPoller`.
+//
+// Light on purpose: the status-line path imports this, and it must not pull in the relay.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexLimitsPoller = exports.CODEX_LIMITS_POLL_MS = exports.LIMITS_MIN_INTERVAL_MS = exports.LIMITS_REFRESH_MS = void 0;
+exports.claudeLimitsFromStatus = claudeLimitsFromStatus;
+exports.codexLimitsReport = codexLimitsReport;
+exports.limitsKey = limitsKey;
+exports.limitsDue = limitsDue;
+exports.postSessionLimits = postSessionLimits;
+const api_1 = require("../api");
+/** A report at least this often while the numbers stand still — the screen's "updated" time. */
+exports.LIMITS_REFRESH_MS = 10 * 60_000;
+/** …and no more often than this when they move. */
+exports.LIMITS_MIN_INTERVAL_MS = 60_000;
+exports.CODEX_LIMITS_POLL_MS = 10 * 60_000;
+const CLAUDE_WINDOWS = [
+    ["five_hour", 5 * 60],
+    ["seven_day", 7 * 24 * 60],
+];
+const pct = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.min(100, Math.round(v * 10) / 10) : undefined;
+const isoFromEpochSeconds = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? new Date(v * 1000).toISOString() : undefined;
+/**
+ * Claude Code's status-line JSON → a report, or null when it carries neither a window nor a cost
+ * (an API-key session before its first answer, or an older Claude Code).
+ */
+function claudeLimitsFromStatus(status) {
+    const s = (status ?? {});
+    const limits = (s.rate_limits ?? {});
+    const windows = [];
+    for (const [kind, minutes] of CLAUDE_WINDOWS) {
+        const w = limits[kind];
+        const usedPercent = pct(w?.used_percentage);
+        if (usedPercent === undefined)
+            continue;
+        const resetsAt = isoFromEpochSeconds(w?.resets_at);
+        windows.push({ kind, usedPercent, windowMinutes: minutes, ...(resetsAt ? { resetsAt } : {}) });
+    }
+    const cost = (s.cost ?? {});
+    const total = cost.total_cost_usd;
+    const totalCostUsd = typeof total === "number" && Number.isFinite(total) && total >= 0 ? Math.round(total * 1e6) / 1e6 : undefined;
+    const plan = typeof s.subscription_type === "string" && s.subscription_type ? s.subscription_type.slice(0, 40) : undefined;
+    if (windows.length === 0 && totalCostUsd === undefined)
+        return null;
+    return { runtime: "claude-code", ...(plan ? { plan } : {}), windows, ...(totalCostUsd !== undefined ? { totalCostUsd } : {}) };
+}
+/** Codex's account limits → a report, or null when it has no window to show. */
+function codexLimitsReport(limits) {
+    if (!limits || limits.windows.length === 0)
+        return null;
+    return {
+        runtime: "codex",
+        ...(limits.plan ? { plan: limits.plan.slice(0, 40) } : {}),
+        windows: limits.windows.map((w) => ({
+            kind: w.kind,
+            usedPercent: Math.min(100, Math.max(0, w.usedPercent)),
+            ...(w.windowMinutes ? { windowMinutes: w.windowMinutes } : {}),
+            ...(w.resetsAt ? { resetsAt: w.resetsAt } : {}),
+        })),
+    };
+}
+/** The part of a report that, when it changes, is news: whole percentages and cents. */
+function limitsKey(report) {
+    const windows = report.windows.map((w) => `${w.kind}:${Math.floor(w.usedPercent)}:${w.resetsAt ?? ""}`).join(",");
+    const cents = report.totalCostUsd === undefined ? "" : Math.floor(report.totalCostUsd * 100);
+    return `${report.plan ?? ""}|${windows}|${cents}`;
+}
+function limitsDue(prev, report, now) {
+    if (!prev)
+        return true;
+    if (now - prev.at >= exports.LIMITS_REFRESH_MS)
+        return true;
+    return now - prev.at >= exports.LIMITS_MIN_INTERVAL_MS && prev.key !== limitsKey(report);
+}
+/** Send one report for a named session, with the device credential. Never throws. */
+async function postSessionLimits(auth, session, report, request) {
+    try {
+        await request(auth, "POST", "/api/device-api/session-limits", { session, ...report });
+        return { kind: "sent" };
+    }
+    catch (err) {
+        if (err instanceof api_1.ApiError) {
+            // Express's own 404 carries no code: a server from before this route.
+            if (err.status === 404 && !err.code)
+                return { kind: "not-deployed" };
+            if (err.status >= 400 && err.status < 500 && err.status !== 429) {
+                return { kind: "refused", status: err.status, code: err.code, message: err.message };
+            }
+        }
+        return { kind: "failed", message: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * Every 10 minutes, while this relay hosts a Codex session: read the account's limits once
+ * (they are the account's, so one read serves every session) and report them for each session.
+ * A server without the route is asked again an hour later, not every round.
+ */
+class CodexLimitsPoller {
+    deps;
+    timer;
+    running = false;
+    notDeployedUntil = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    start() {
+        if (this.timer)
+            return;
+        const every = this.deps.setInterval ??
+            ((fn, ms) => {
+                const t = setInterval(fn, ms);
+                t.unref?.();
+                return { cancel: () => clearInterval(t) };
+            });
+        this.timer = every(() => void this.poll(), exports.CODEX_LIMITS_POLL_MS);
+    }
+    stop() {
+        this.timer?.cancel();
+        this.timer = undefined;
+    }
+    /** One round; resolves when every report was attempted. Public for tests and a first run. */
+    async poll(now = Date.now()) {
+        if (this.running || now < this.notDeployedUntil)
+            return;
+        // In this order: no Codex session, no binary lookup (a machine without Codex logs nothing).
+        const sessions = this.deps.sessions();
+        if (sessions.length === 0)
+            return;
+        const auth = this.deps.auth();
+        const binary = auth ? this.deps.binary() : undefined;
+        if (!auth || !binary)
+            return;
+        this.running = true;
+        try {
+            const report = codexLimitsReport(await this.deps.read(binary));
+            if (!report)
+                return;
+            for (const session of sessions) {
+                const outcome = await postSessionLimits(auth, session, report, this.deps.request);
+                if (outcome.kind === "not-deployed") {
+                    this.notDeployedUntil = now + 60 * 60_000;
+                    this.deps.log("this BayChat server does not take plan limits yet — asking again in an hour");
+                    return;
+                }
+                if (outcome.kind === "refused" || outcome.kind === "failed") {
+                    this.deps.log(`plan limits for ${session} not sent: ${outcome.message}`);
+                }
+            }
+        }
+        catch (err) {
+            this.deps.log(`plan limits: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+}
+exports.CodexLimitsPoller = CodexLimitsPoller;