baychat 0.21.5 → 0.23.0

package/dist/relay/terminal-pane.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPane = detectPane;
+exports.verifyPane = verifyPane;
+exports.typeIntoPane = typeIntoPane;
+const child_process_1 = require("child_process");
+const profiles_1 = require("./profiles");
+/**
+ * Read the pane out of the environment — INSIDE the session, never in the daemon.
+ *
+ * Same principle as `runtimeBin` and `resumeId`: the process that is actually in the
+ * terminal is the only one that can answer, and the daemon guessing is how this codebase
+ * has been bitten before. `relay attach` runs in the session; its environment carries
+ * `$TMUX` and `$TMUX_PANE` (measured: `/tmp/tmux-1003/default,1381496,1` and `%1`, matching
+ * `display-message -p '#{pane_id}'` from outside).
+ *
+ * Every multiplexer we can RECOGNISE is returned, including ones we cannot yet type into.
+ * That is deliberate: "you are in screen, and tmux is what this supports" is a far better
+ * answer than the silence of not looking.
+ */
+function detectPane(env = process.env) {
+    const tmux = env.TMUX;
+    const tmuxPane = env.TMUX_PANE;
+    if (tmux && tmuxPane) {
+        // "<socket>,<server pid>,<session>" — only the first field addresses the server.
+        const socket = tmux.split(",")[0];
+        if (socket)
+            return { kind: "tmux", socket, pane: tmuxPane };
+    }
+    if (env.STY)
+        return { kind: "screen", session: env.STY, window: env.WINDOW ?? "0" };
+    if (env.ZELLIJ)
+        return { kind: "zellij", pane: env.ZELLIJ_PANE_ID };
+    return undefined;
+}
+/** The binary whose name must still be in the pane for a send to be allowed. */
+function expectedCommand(runtime) {
+    return (0, profiles_1.profileFor)(runtime)?.bin ?? runtime;
+}
+/**
+ * Is this pane still the session we recorded?
+ *
+ * ⚠️ THE CHECK THAT KEEPS THIS FROM BEING A REMOTE SHELL. A pane outlives the program in
+ * it: an agent that exited leaves a **shell prompt** on the same pane id, and typing into a
+ * shell is running a command. So the foreground command is compared against the runtime
+ * recorded at attach, and anything else — dead pane, different program, tmux not answering
+ * — is a refusal.
+ *
+ * `#{pane_current_command}` is the FOREGROUND process, which is what a keystroke would
+ * actually reach. Using it also means a pane sitting in a subprocess refuses rather than
+ * typing into that subprocess, which is fail-closed in the direction we want.
+ */
+function verifyPane(handle, runtime, run = (file, args) => (0, child_process_1.execFileSync)(file, args, { encoding: "utf8", timeout: 5_000 }), ownerPid) {
+    if (handle.kind === "zellij") {
+        return {
+            ok: false,
+            reason: "this session is running in zellij, which cannot be typed into yet — tmux and screen can.",
+        };
+    }
+    if (handle.kind === "screen") {
+        // SCREEN CANNOT BE ASKED WHAT IS RUNNING IN A WINDOW. tmux answers
+        // `#{pane_current_command}`; screen has no equivalent, and `screen -ls` says only that
+        // a session exists. So the same question is put to the PROCESS instead: is the runtime
+        // this session recorded at attach still alive, and still that runtime?
+        //
+        // This is a weaker check than tmux's in one specific way, and it is worth naming: it
+        // proves the agent is RUNNING, not that it is the foreground program of that window.
+        // A human who switched that window to a shell would be typed at. The window number is
+        // pinned from `$WINDOW` precisely to keep that to the window the agent started in.
+        if (ownerPid === undefined) {
+            return { ok: false, reason: "this screen session did not record its runtime process, so it cannot be typed into safely." };
+        }
+        return runtimeStillRunning(ownerPid, runtime, run);
+    }
+    let out;
+    try {
+        out = run("tmux", [
+            "-S",
+            handle.socket,
+            "display-message",
+            "-p",
+            "-t",
+            handle.pane,
+            "#{pane_dead} #{pane_current_command}",
+        ]).trim();
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: `tmux could not find pane ${handle.pane} any more (${errText(err)}).`,
+        };
+    }
+    const [dead, current] = out.split(/\s+/);
+    if (dead !== "0")
+        return { ok: false, reason: `pane ${handle.pane} has exited.` };
+    const want = expectedCommand(runtime);
+    if (current !== want) {
+        return {
+            ok: false,
+            reason: `pane ${handle.pane} is running ${current ?? "nothing"}, not ${want} — refusing to type into it.`,
+        };
+    }
+    return { ok: true };
+}
+/**
+ * Is `pid` still running, and still the runtime we recorded?
+ *
+ * Both halves matter. A pid alone proves nothing — pids are reused, and the reused one is
+ * exactly as likely to be a shell as anything else. The command name is what makes it an
+ * identification rather than a hope.
+ */
+function runtimeStillRunning(pid, runtime, run) {
+    const want = expectedCommand(runtime);
+    let comm;
+    try {
+        comm = run("ps", ["-p", String(pid), "-o", "comm="]).trim();
+    }
+    catch {
+        return { ok: false, reason: `the ${want} process for this session is no longer running.` };
+    }
+    if (!comm)
+        return { ok: false, reason: `the ${want} process for this session has exited.` };
+    // `comm` is truncated to 15 characters by the kernel, so compare on that basis rather
+    // than demanding equality — "claude" and "codex" are short, but a longer runtime name
+    // would otherwise never match itself.
+    if (comm !== want && !want.startsWith(comm)) {
+        return { ok: false, reason: `that process is ${comm}, not ${want} — refusing to type into it.` };
+    }
+    return { ok: true };
+}
+/**
+ * ⚠️ Characters that must never reach a multiplexer's "type this" command.
+ *
+ * `screen -X stuff` parses `^X` as a control character and `\` as an escape, so a string
+ * containing either would send something other than itself. Our text comes from a fixed
+ * table and contains neither — this refuses anyway, because the day somebody adds a row
+ * with a backslash in it is the day that stops being true, and a test failing is a much
+ * better outcome than a control character being typed into a terminal.
+ */
+const UNSAFE_TO_TYPE = /[\^\\\r\n\x00-\x1f]/;
+/**
+ * Type one line into the pane and press Enter.
+ *
+ * ⚠️ `-l` IS LOAD-BEARING. Without it `send-keys` reads its arguments as KEY NAMES, so text
+ * containing `C-c` or `Escape` would be a signal rather than characters. With it the string
+ * is sent literally and Enter is a separate, deliberate key.
+ *
+ * `text` must come from the command table in `session-commands.ts` and NEVER from a chat
+ * message. That is the rule the whole feature rests on: the wire carries a command NAME,
+ * and the keystrokes are ours. There is deliberately no argument here that a message could
+ * reach.
+ */
+async function typeIntoPane(handle, runtime, text, deps = {}) {
+    // Checked BEFORE the pane, so a bad row fails on every machine rather than only on the
+    // multiplexer that would have mangled it.
+    if (UNSAFE_TO_TYPE.test(text)) {
+        return { ok: false, reason: "that command contains characters that must never be typed into a terminal." };
+    }
+    const verify = deps.verify ?? verifyPane;
+    const check = verify(handle, runtime, undefined, deps.ownerPid);
+    if (!check.ok)
+        return check;
+    const exec = deps.exec ?? runQuietly;
+    try {
+        if (handle.kind === "tmux") {
+            // `-l` sends the string LITERALLY. Without it send-keys reads its arguments as key
+            // NAMES, so text containing `C-c` would be a signal rather than characters.
+            await exec("tmux", ["-S", handle.socket, "send-keys", "-t", handle.pane, "-l", "--", text]);
+            await exec("tmux", ["-S", handle.socket, "send-keys", "-t", handle.pane, "Enter"]);
+            return { ok: true };
+        }
+        if (handle.kind === "screen") {
+            // `-p <window>` pins the window the agent started in; screen's "current window" is
+            // whichever the human last looked at, which is not the same thing.
+            //
+            // Enter goes as its own `stuff` of `^M`, which screen reads as a carriage return.
+            // That is the one place a `^` is deliberate — and it is ours, never a message's:
+            // `UNSAFE_TO_TYPE` above guarantees the text itself carries none.
+            const at = ["-S", handle.session, "-p", handle.window, "-X", "stuff"];
+            await exec("screen", [...at, text]);
+            await exec("screen", [...at, "^M"]);
+            return { ok: true };
+        }
+        return { ok: false, reason: `${handle.kind} cannot be typed into yet.` };
+    }
+    catch (err) {
+        return { ok: false, reason: `${handle.kind} refused the keystrokes: ${errText(err)}` };
+    }
+}
+function runQuietly(file, args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)(file, args, { timeout: 5_000 }, (err) => (err ? reject(err) : resolve()));
+    });
+}
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/relay/types.js

@@ -1,11 +1,2 @@
 "use strict";
-/**
- * Shared types for the relay daemon.
- *
- * The relay's job is narrow: hold `/updates`, decide which local session an
- * event belongs to, and wake that session — once, never twice concurrently.
- * It deliberately does NOT decide whether the session should reply. That
- * judgement is the server's (`shouldRespond`) and the woken session's; the
- * relay only carries the message across the process boundary.
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/runtime-binary.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRuntimeBinary = resolveRuntimeBinary;
 exports.describeResolution = describeResolution;
 exports.spawnPlanFor = spawnPlanFor;
+exports.probeBinaryVersion = probeBinaryVersion;
 exports.summarizeProbe = summarizeProbe;
 exports.currentBinaryEnv = currentBinaryEnv;
 exports.summarizeResolutionFailure = summarizeResolutionFailure;
@@ -213,6 +214,22 @@ function spawnPlanFor(candidate, platform) {
 }
 /** How long a `--version` probe may run before it is treated as broken. */
 const PROBE_TIMEOUT_MS = 5_000;
+/**
+ * `<binary> --version`, without blocking the event loop — for a caller that probes a known path
+ * while other work runs (the relay, before starting an agent). Same rules as the resolution
+ * probe: no shell, the environment the agent will get, `summarizeProbe` decides.
+ */
+function probeBinaryVersion(binaryPath, env) {
+    const plan = spawnPlanFor(binaryPath, process.platform);
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(plan.file, [...plan.prefixArgs, "--version"], { timeout: PROBE_TIMEOUT_MS, windowsHide: true, shell: false, env, encoding: "utf8" }, (err, stdout, stderr) => {
+            const status = err ? (typeof err.code === "number" ? err.code : null) : 0;
+            // A non-zero exit is still a run: only a failure to run at all is an `error`.
+            const failedToRun = err && typeof err.code !== "number" ? err : undefined;
+            resolve(summarizeProbe({ status, stdout: stdout ?? "", stderr: stderr ?? "", error: failedToRun }));
+        });
+    });
+}
 /** The most stderr worth quoting back to a user in a rejection reason. */
 const PROBE_DETAIL_LIMIT = 200;
 /**

package/dist/runtimes.js

@@ -39,6 +39,7 @@ exports.RUNTIMES = [
     "desktop",
     "pi",
     "hermes",
+    "dsh",
     "generic",
 ];
 const GENERIC_RESUME_NOTE = `The relay can only wake this session while \`attach\` is running. Re-arm it after
@@ -483,6 +484,18 @@ DELIVERY PENDING and waits for a human — re-arm attach after every wake, witho
         fallback: "Hermes is a self-hosted agent: it authenticates with its own agent token and long-polls for messages, so there is nothing to install on this machine. Pair it from the app, then add BayChat under `mcp_servers:` in ~/.hermes/config.yaml to give it tools.",
         needsRestart: false,
     },
+    dsh: {
+        id: "dsh",
+        label: "DeepSeek Harness",
+        mcp: { kind: "manual", describe: "merged into ~/.dsh/cordis.patch.yml by `baychat connect dsh`" },
+        // ~/.dsh/skills is rank 400 in dsh's skill search and ~/.agents/skills is 500 [source], so
+        // this copy SHADOWS a Codex skill a client already has — which would tell dsh to attach as
+        // `--runtime codex`. It must be written here, never shared with the Codex file.
+        command: { dir: ".dsh/skills/baychat", file: "SKILL.md", frontmatter: true, render: (ctx) => renderCommand(ctx, true) },
+        invocation: '/baychat <name> ["<Group Title>"]',
+        relay: { runtime: "dsh", reArm: "background-every-wake", resumeNote: GENERIC_RESUME_NOTE },
+        needsRestart: true,
+    },
     generic: {
         id: "generic",
         label: "Generic MCP client",

package/dist/session-command.js

@@ -7,6 +7,7 @@ const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/client/streamable
 const config_1 = require("./config");
 const session_name_1 = require("./session-name");
 const owner_pid_1 = require("./relay/owner-pid");
+const terminal_pane_1 = require("./relay/terminal-pane");
 const profiles_1 = require("./relay/profiles");
 const message_format_1 = require("./relay/message-format");
 const commands_1 = require("./relay/commands");
@@ -69,15 +70,16 @@ async function cmdJoinSession(args) {
     const joining = Boolean(options.session || options.group || options.destination);
     const runtime = options.runtime ?? (0, owner_pid_1.detectRuntime)(profiles_1.RUNTIME_PROFILES);
     if (joining && !runtime)
-        throw new Error("Cannot detect this runtime. Pass --runtime codex or --runtime claude.");
+        throw new Error("Cannot detect this runtime. Pass --runtime codex, --runtime claude, --runtime cursor, or --runtime dsh.");
     if (runtime === "hermes") {
         throw new Error("Hermes is a persistent agent. Use baychat connect hermes.");
     }
     if (joining &&
         runtime !== "codex" &&
         runtime !== "claude" &&
-        runtime !== "cursor") {
-        throw new Error("Supported coding runtimes: codex, claude, cursor.");
+        runtime !== "cursor" &&
+        runtime !== "dsh") {
+        throw new Error("Supported coding runtimes: codex, claude, cursor, dsh.");
     }
     let name = joining
         ? (options.session ?? (await (0, session_name_1.automaticSessionName)(runtime)))
@@ -189,6 +191,17 @@ async function cmdJoinSession(args) {
         return 1;
     }
     console.log("Connecting incoming messages…");
+    // SAID AT JOIN, NOT AT FAILURE. `/clear` and `/new` from the app work by typing into
+    // this session's terminal, which needs a multiplexer pane to address (see
+    // relay/terminal-pane.ts). Somebody who learns that only when a command refuses has
+    // already been let down once; one line here is the whole difference.
+    // ONE LINE, AND ONLY WHEN IT IS ACTIONABLE. `baychat start` puts an agent somewhere these
+    // commands can reach without anybody learning what a multiplexer is, so the note names
+    // the one word that fixes it and never the machinery underneath.
+    const pane = (0, terminal_pane_1.detectPane)();
+    if (!pane) {
+        console.log("Note: /clear and /new from the app cannot reach this session. Start it with `baychat` next time and they will. Everything else works either way.");
+    }
     const attach = () => (0, commands_1.cmdRelayAttach)({
         session: name,
         runtime: runtime,

package/dist/skill-bootstrap.js

@@ -23,14 +23,22 @@ instructions; it does not log in, join a room, or start a receiver. Do not inspe
 installed source or credential files. Package updates supply the new workflow
 automatically; there is no separate skill-refresh command for the user.
 
-For an update request (\`--update\`), first run \`npm install --global baychat@latest\`
-yourself. On an update-only request, run \`baychat --version\`, confirm it briefly,
-and stop without loading the join workflow, joining or sending messages. If a join
-was also requested, load the new workflow and keep the original name and group.
-If BayChat is missing, install it with the same npm command and retry the loader.
-Install only once per request; stop on failure with its short error. Do not retry
-installations or change npm permissions. No skill refresh or host restart is
-needed just to load newer workflow instructions from the package.
+For an update request (\`--update\`), run \`baychat update\` and report what it prints.
+That one command does every part: the npm package, every connected client's config, and
+a relay restart. The relay is the step that matters most and the easiest to miss — a
+running daemon holds its old code in memory, so an npm install alone leaves the machine
+on the previous version with nothing saying so.
+
+Do not run npm yourself, and do not run the steps separately. A sequence the model has
+to remember is a sequence the model will one day do half of; \`baychat update\` is
+idempotent, refreshes only what is already connected, and never sets anything up.
+If BayChat is not installed at all, install it once with
+\`npm install --global baychat@latest\` and retry. Stop on failure with its short error;
+do not retry installs or change npm permissions.
+
+On an update-only request, stop after reporting — do not load the join workflow, join, or
+send messages. If a join was also requested, load the new workflow afterwards and keep the
+original name and group.
 
 Missing MCP setup is handled by the returned workflow inside this session.
 Do not ask the user to run connect. Authentication approvals and host reloads

package/dist/start-command.js

@@ -0,0 +1,235 @@
+"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.START_RUNTIMES = void 0;
+exports.startRefusal = startRefusal;
+exports.cmdStart = cmdStart;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_1 = require("./config");
+const terminal_pane_1 = require("./relay/terminal-pane");
+const profiles_1 = require("./relay/profiles");
+const runtime_binary_1 = require("./runtime-binary");
+const update_command_1 = require("./update-command");
+/**
+ * `baychat start [name]` — the whole product in one command.
+ *
+ * ── THE BAR THIS EXISTS TO MEET ───────────────────────────────────────────────────────
+ *
+ * Karmen's, 2026-09-14: *"everything we do we have to make very easy, basically just
+ * download baychat, and then start session, nothing else."*
+ *
+ * So: this launches the person's agent, inside a terminal multiplexer when one is
+ * available, and says nothing about multiplexers at all. They type one word. `/clear` and
+ * `/new` from the app then work, because `relay attach` finds `$TMUX`/`$TMUX_PANE` waiting
+ * for it — and if no multiplexer is installed, the agent still starts and everything except
+ * those two commands still works. **The fallback is silent on purpose.** A warning about a
+ * program they have never heard of, at the moment they are trying to start work, is exactly
+ * the "something else" this command exists to remove.
+ *
+ * ── WHY NOT A PSEUDO-TERMINAL OF OUR OWN ──────────────────────────────────────────────
+ *
+ * `node-pty` would remove the multiplexer requirement completely and work on Windows too.
+ * It is 64 MB unpacked and compiles through node-gyp on install, so `npx baychat` would
+ * start demanding a C++ toolchain — which fails for everyone, not only the people who
+ * wanted `/clear`. Checked 2026-09-14 and rejected on that basis, not on taste.
+ *
+ * ── WHY IT DOES NOT JUST JOIN, TOO ────────────────────────────────────────────────────
+ *
+ * Joining happens INSIDE the agent (the installed skill runs `baychat join`), because that
+ * is the only place the session's own runtime id, binary and pane can be read. This command
+ * gets the agent into a terminal we can reach; the agent does the rest, exactly as it does
+ * today.
+ */
+const PREFERENCE_FILE = "start-runtime.json";
+/**
+ * Runtimes `start` never probes for or launches. dsh (Ruling R27): it is experimental and
+ * meant to run only in a VM, and BayChat runs it through the relay over ACP
+ * (`baychat connect dsh`), which enforces its modes — a terminal launch would not.
+ */
+const NOT_STARTED = {
+    dsh: "DeepSeek Harness is not started from here: the relay runs it over ACP. Set it up with `baychat connect dsh`.",
+};
+/** Runtimes worth probing for, best-supported first. */
+exports.START_RUNTIMES = ["claude", "codex", ...profiles_1.RUNTIME_PROFILES.map((p) => p.id)].filter((id) => !Object.hasOwn(NOT_STARTED, id));
+/** Why `start` will not launch `runtime`, or undefined when it will. */
+function startRefusal(runtime) {
+    return Object.hasOwn(NOT_STARTED, runtime) ? NOT_STARTED[runtime] : undefined;
+}
+async function cmdStart(args) {
+    if (!(0, config_1.loadDeviceCredentials)()) {
+        console.error("This machine is not signed in yet. Run `npx baychat login` first.");
+        return 1;
+    }
+    // THE UPDATE NOBODY HAS TO REMEMBER.
+    //
+    // Shipping a CLI change reaches nobody until the package is refetched, every connected
+    // client's config is rewritten, and the relay is restarted — a live daemon holds old code
+    // in memory indefinitely. Three steps, in different places, and the failure is silence.
+    // So the one command people actually run does them, once a day.
+    //
+    // ⚠️ NEVER BLOCKS STARTING WORK. Any failure — offline, npm down, a permissions problem —
+    // is swallowed: the agent starts anyway. An update is an improvement to a session, never
+    // a precondition for one, and a person who cannot start their agent because a background
+    // refresh failed would rightly never trust this command again.
+    if (!args.includes("--no-update") && (0, update_command_1.autoUpdateDue)()) {
+        try {
+            await (0, update_command_1.cmdUpdate)({ quiet: true });
+        }
+        catch {
+            /* Starting the agent matters more than being current. */
+        }
+    }
+    const runtimeFlag = valueAfter(args, "--runtime");
+    const positional = args.filter((a) => !a.startsWith("--") && a !== runtimeFlag);
+    const name = positional[0]?.trim();
+    const runtime = runtimeFlag ?? (await chooseRuntime());
+    if (!runtime)
+        return 1;
+    const refusal = startRefusal(runtime);
+    if (refusal) {
+        console.error(refusal);
+        return 1;
+    }
+    const binary = (0, runtime_binary_1.resolveRuntimeBinary)(runtime, (0, runtime_binary_1.currentBinaryEnv)());
+    if (!binary.ok) {
+        console.error(`Could not start ${runtime}: ${binary.reason}`);
+        return 1;
+    }
+    // ALREADY INSIDE ONE? Then just run the agent. Nesting multiplexers sends every prefix
+    // key to the wrong one, and the person already has everything this command provides.
+    const inside = (0, terminal_pane_1.detectPane)();
+    const multiplexer = inside ? undefined : firstAvailable(["tmux", "screen"]);
+    if (!multiplexer) {
+        const result = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        return result.status ?? 0;
+    }
+    const sessionName = name || "baychat";
+    const argv = multiplexer === "tmux"
+        ? // `-A` attaches to an existing session of that name instead of failing, so running
+            // this twice returns you to your agent rather than erroring at you.
+            ["new", "-A", "-s", sessionName, binary.path]
+        : ["-S", sessionName, "-R", binary.path];
+    const result = (0, child_process_1.spawnSync)(multiplexer, argv, { stdio: "inherit" });
+    if (result.error) {
+        // Falling back rather than failing: the multiplexer is an enhancement, and refusing to
+        // start somebody's agent because of one would be the tail wagging the dog.
+        const direct = (0, child_process_1.spawnSync)(binary.path, [], { stdio: "inherit" });
+        return direct.status ?? 0;
+    }
+    return result.status ?? 0;
+}
+/**
+ * Which agent to start.
+ *
+ * Asks only when it genuinely cannot tell — one installed runtime needs no question — and
+ * remembers the answer, because being asked the same thing every morning is "something
+ * else" by another name.
+ */
+async function chooseRuntime() {
+    const remembered = readPreference();
+    if (remembered)
+        return remembered;
+    const env = (0, runtime_binary_1.currentBinaryEnv)();
+    const installed = [...new Set(exports.START_RUNTIMES)].filter((id) => (0, runtime_binary_1.resolveRuntimeBinary)(id, env).ok);
+    if (installed.length === 0) {
+        console.error("No coding agent found on this machine. Install one (Claude Code or Codex) and run this again.");
+        return undefined;
+    }
+    if (installed.length === 1) {
+        writePreference(installed[0]);
+        return installed[0];
+    }
+    console.log("Which agent should BayChat start?");
+    installed.forEach((id, index) => console.log(`  ${index + 1}. ${id}`));
+    const answer = await ask(`Choose 1-${installed.length}: `);
+    const chosen = installed[Number(answer.trim()) - 1];
+    if (!chosen) {
+        console.error("Not one of the options.");
+        return undefined;
+    }
+    writePreference(chosen);
+    return chosen;
+}
+function ask(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+    }));
+}
+function preferencePath() {
+    return path.join((0, config_1.configDir)(), PREFERENCE_FILE);
+}
+function readPreference() {
+    try {
+        const raw = JSON.parse(fs.readFileSync(preferencePath(), "utf8"));
+        return typeof raw.runtime === "string" ? raw.runtime : undefined;
+    }
+    catch {
+        // Absent or unreadable is simply "not chosen yet" — never an error worth showing.
+        return undefined;
+    }
+}
+function writePreference(runtime) {
+    try {
+        fs.mkdirSync((0, config_1.configDir)(), { recursive: true });
+        fs.writeFileSync(preferencePath(), JSON.stringify({ runtime }, null, 2));
+    }
+    catch {
+        // Not remembering costs one question next time. Never worth failing a start for.
+    }
+}
+/**
+ * The first of these that RUNS, not the first on the PATH.
+ *
+ * The distinction has already cost this codebase a week: the relay's runtime probe picked a
+ * binary that existed and could not start, and resolution fell through to a version too old
+ * for the feature it was being asked for.
+ */
+function firstAvailable(candidates) {
+    for (const candidate of candidates) {
+        const probe = (0, child_process_1.spawnSync)(candidate, ["--version"], { stdio: "ignore" });
+        if (!probe.error && probe.status === 0)
+            return candidate;
+    }
+    return undefined;
+}
+function valueAfter(args, flagName) {
+    const index = args.indexOf(flagName);
+    return index === -1 ? undefined : args[index + 1];
+}