baychat 0.38.0 → 0.40.0

package/dist/relay/daemon.js

@@ -48,6 +48,7 @@ const bay_deleted_1 = require("../bay-deleted");
 const context_report_1 = require("../context-report");
 const codex_context_1 = require("./codex-context");
 const session_commands_1 = require("./session-commands");
+const terminal_stop_1 = require("./terminal-stop");
 const terminal_pane_1 = require("./terminal-pane");
 const compact_command_1 = require("./compact-command");
 const fresh_start_1 = require("./fresh-start");
@@ -651,6 +652,13 @@ class RelayDaemon {
         // own app-server daemon, for the thread the join corroborated (codex-control.ts).
         if (await this.runJoinedCodexCommand(session, target, command, compact.focus, say))
             return;
+        // `/stop` for a session in someone's own terminal (the app's Stop): owner only, one interrupt
+        // through `interruptPane` (terminal-stop.ts). Relay-run sessions keep their own `/stop` below.
+        if (command.id === "stop" && !target.acp && !target.codex) {
+            if (target.delivery === "channel" && !this.channelLinked(session))
+                return say((0, channel_sessions_1.channelGoneReason)(session));
+            return (0, terminal_stop_1.runTerminalStop)(session, target, message, say);
+        }
         // `/mode-*`, `/stop`, and what `/status` `/exit` `/clear` `/new` mean with no terminal.
         if (await (0, commands_1.runAcpSessionCommand)(this.acp, session, target, message, command, say))
             return;
@@ -1887,6 +1895,7 @@ class RelayDaemon {
      */
     registerChannel(frame, sock) {
         const previous = this.channels.get(frame.session);
+        const before = this.registry.get(frame.session);
         if (previous && previous !== sock) {
             this.log(`replacing channel for ${frame.session}: dropping the previous one`);
             (0, socket_1.writeFrame)(previous, { type: "error", message: channel_sessions_1.CHANNEL_REPLACED });
@@ -1905,6 +1914,12 @@ class RelayDaemon {
         (0, socket_1.writeFrame)(sock, { type: "attached", session: frame.session, delivery: "channel" });
         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})`);
+        // Another Claude Code process took this name (a new terminal, 2026-10-30): its memory starts
+        // empty, so the server must not keep showing the old process's reading and tidy count.
+        // The same process re-registering (a reconnect) keeps its pid and sends nothing.
+        if (before?.ownerPid && frame.ownerPid && before.ownerPid !== frame.ownerPid) {
+            this.reportContext(frame.session, { runtime: "claude-code", event: "session_start", source: "exact" });
+        }
     }
     /**
      * Forget every channel session that is DEAD: its channel link is closed and its Claude Code

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

@@ -114,19 +114,26 @@ function permissionHook(cli, flags) {
                 ],
             },
         ],
+        ...afterHooks(cli),
     };
 }
-/** The tools the after-hook watches: the ones a once-rule can be written for (permission-rule.ts). */
-const DENIED_AFTER_MATCHER = "Bash|WebFetch|mcp__.*";
+/**
+ * The tools the after-hook watches: every tool that can draw a permission dialog — a card answered at
+ * the keyboard is closed from here (card-after.ts) — which covers the once-rule tools too
+ * (permission-rule.ts: Bash, WebFetch, MCP).
+ */
+const AFTER_MATCHER = "Bash|Edit|Write|MultiEdit|NotebookEdit|WebFetch|WebSearch|mcp__.*";
 /** The after-hook is async and returns in milliseconds; this bounds only a wedged one. */
-const DENIED_AFTER_TIMEOUT_SECONDS = 30;
+const AFTER_TIMEOUT_SECONDS = 30;
 /**
- * The denied-command card's hooks (docs/features/DENIED_COMMAND_CARD.md). `flags` are the same
- * session flags approve-hook gets in that file.
+ * The async after-hook (`denied-after`): takes an "Allow once" rule back out, and closes a permission
+ * card answered in the terminal instead (fix/needs-you-closes-itself — measured on Claude Code
+ * 2.1.316, a "Yes" at the keyboard leaves approve-hook parked and its card open). In every file that
+ * has approve-hook, whatever the denied-card switch says.
  */
-function deniedCardHooks(cli, flags) {
+function afterHooks(cli) {
     const after = {
-        matcher: DENIED_AFTER_MATCHER,
+        matcher: AFTER_MATCHER,
         hooks: [
             {
                 type: "command",
@@ -134,10 +141,17 @@ function deniedCardHooks(cli, flags) {
                 args: [cli.entry, "denied-after"],
                 // Never in a tool call's way: Claude Code starts it and carries on.
                 async: true,
-                timeout: DENIED_AFTER_TIMEOUT_SECONDS,
+                timeout: AFTER_TIMEOUT_SECONDS,
             },
         ],
     };
+    return { PostToolUse: [after], PostToolUseFailure: [after] };
+}
+/**
+ * The denied-command card's hooks (docs/features/DENIED_COMMAND_CARD.md). `flags` are the same
+ * session flags approve-hook gets in that file.
+ */
+function deniedCardHooks(cli, flags) {
     return {
         PermissionDenied: [
             {
@@ -155,8 +169,7 @@ function deniedCardHooks(cli, flags) {
                 ],
             },
         ],
-        PostToolUse: [after],
-        PostToolUseFailure: [after],
+        ...afterHooks(cli),
     };
 }
 /** `settings` with the denied-command card's hooks added beside its own. Pure. */

package/dist/relay/launcher/loop.js

@@ -133,7 +133,18 @@ async function reportSessionSpots(deps, auth, signal, last, log) {
     if (key === last)
         return last;
     try {
-        await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions }, signal);
+        try {
+            await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions }, signal);
+        }
+        catch (err) {
+            // A server older than the `withinSpotId` hint (2026-10-30) refuses the whole report as
+            // INVALID_SESSION_SPOTS: send it again without the hints, so "Start again" places still land.
+            const hinted = sessions.some((s) => s.withinSpotId !== undefined);
+            if (!(hinted && err instanceof api_1.ApiError && err.status === 400))
+                throw err;
+            const plain = sessions.map(({ withinSpotId: _hint, ...rest }) => rest);
+            await deps.request(auth, "PUT", "/api/device-api/launch-sessions", { sessions: plain }, signal);
+        }
         return key;
     }
     catch (err) {

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

@@ -37,6 +37,7 @@ exports.MAX_SESSION_SPOTS = void 0;
 exports.sessionSpots = sessionSpots;
 exports.realRealpath = realRealpath;
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const policy_1 = require("../../launch/policy");
 const argv_1 = require("./argv");
 /** The server takes at most this many per report. */
@@ -56,13 +57,27 @@ function sessionSpots(sessions, policy, deps) {
             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" });
+        const offered = folders.filter((f) => f.spot.runtimes.includes(runtime));
+        const match = real ? offered.find((f) => f.path === real) : undefined;
+        // The deepest spot folder above it: the longest path that is a proper prefix at a separator.
+        const within = real && !match ? offered.filter((f) => isInside(real, f.path)).sort((a, b) => b.path.length - a.path.length)[0] : undefined;
+        out.push({
+            name: session.name,
+            spotId: match?.spot.id ?? null,
+            ...(within ? { withinSpotId: within.spot.id } : {}),
+            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));
 }
+/** Is `dir` strictly inside `parent` (both realpaths)? `/work/web2` is not inside `/work/web`. */
+function isInside(dir, parent) {
+    const prefix = parent.endsWith(path.sep) ? parent : parent + path.sep;
+    return dir.startsWith(prefix);
+}
 function realRealpath(dir) {
     try {
         return fs.realpathSync(dir);

package/dist/relay/pane-interrupt.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTERRUPT_KEYS = void 0;
+exports.isBusy = isBusy;
+exports.interruptPane = interruptPane;
+const child_process_1 = require("child_process");
+const terminal_pane_1 = require("./terminal-pane");
+/**
+ * Stop: interrupt the turn a terminal session is working on (docs/design/AGENT_STOP_UNDO.md §2.5).
+ *
+ * ── THE ONLY KEYSTROKE PATH THAT IS NOT TEXT ─────────────────────────────────────────
+ *
+ * `typeIntoPane` types TEXT, always with `-l`, so nothing it sends can ever be read as a key name.
+ * Stop needs one real key, so it lives here, apart, and is narrower still:
+ *
+ *   1. the same pane checks as every keystroke (`verifyPane`: this user's socket, the runtime still
+ *      in the foreground — a shell left behind is never typed into);
+ *   2. TWO looks 700 ms apart must both show the runtime's own "working" line — no work, no key;
+ *   3. ONE key from a frozen table, by key name, with no `-l` and no Enter;
+ *   4. one more look after 1 s: the working line gone is DONE, still there is FAILED. No second key.
+ *
+ * Escape, not Ctrl-C: in Claude Code and Codex, Esc interrupts the current turn and keeps the
+ * session; Ctrl-C twice EXITS Claude Code, so a doubled Ctrl-C would be an End by accident. The wire
+ * carries the command name `interrupt`, never a key: the key is decided here and only here.
+ */
+exports.INTERRUPT_KEYS = Object.freeze({ claude: "Escape", codex: "Escape" });
+/**
+ * The line each runtime shows while a turn runs. A runtime without a row is never busy.
+ *
+ * Claude Code, captured on this Mac 1 Nov 2026 (native build, a turn running):
+ *   "· Infusing… (3m 25s · ↓ 12.3k tokens · thought for 1s)"
+ * — a spinner glyph, a gerund ending in "…", then "(" and the elapsed time. Older builds added
+ * "· esc to interrupt"; the current one does not, so the time is what proves a turn runs. A finished
+ * turn reads "✻ Worked for 3m 25s" (no "…", no "("), which must NOT match.
+ * Codex: "• Working (8s • esc to interrupt)".
+ */
+const BUSY_LINES = Object.freeze({
+    claude: /^\s*\S\s+\S+…\s+\((?:\d+h\s+)?(?:\d+m\s+)?\d+s\b|esc to interrupt/im,
+    codex: /esc to interrupt/i,
+});
+/** The first look, the second look, and the check after the key, in ms. */
+const SECOND_LOOK_MS = 700;
+const AFTER_KEY_MS = 1000;
+/**
+ * How many lines at the bottom of the pane are read. The working line sits right above the input
+ * box (captured 1 Nov: 8 lines from the bottom, under a two-line tip). Anything higher up is the
+ * conversation — and a chat, a log or a review can QUOTE a working line there while the session is
+ * idle (vps, review of fc377a96e), which must never earn an Escape.
+ */
+const BOTTOM_LINES = 12;
+/** Does this capture show `runtime` working on a turn right now? Only its bottom counts. */
+function isBusy(runtime, capture) {
+    const line = BUSY_LINES[runtime];
+    if (!line)
+        return false;
+    const lines = capture.split("\n");
+    // capture-pane pads to the pane's height with empty lines; the bottom is the last line drawn.
+    while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+        lines.pop();
+    return line.test(lines.slice(-BOTTOM_LINES).join("\n"));
+}
+/** Interrupt the session's current turn, or say honestly why not. Never throws. */
+async function interruptPane(handle, runtime, deps = {}) {
+    if (handle.kind !== "tmux") {
+        return { outcome: "UNREACHABLE", reason: `${handle.kind} can't be stopped from BayChat yet — tmux can.` };
+    }
+    const key = exports.INTERRUPT_KEYS[runtime];
+    if (!key)
+        return { outcome: "UNREACHABLE", reason: `${runtime} can't be stopped from BayChat.` };
+    const check = (deps.verify ?? terminal_pane_1.verifyPane)(handle, runtime, undefined, deps.ownerPid);
+    if (!check.ok)
+        return { outcome: "UNREACHABLE", reason: check.reason };
+    const capture = deps.capture ?? capturePane;
+    const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const exec = deps.exec ?? runQuietly;
+    try {
+        if (!isBusy(runtime, await capture(handle)))
+            return { outcome: "NOTHING_RUNNING" };
+        await sleep(SECOND_LOOK_MS);
+        if (!isBusy(runtime, await capture(handle)))
+            return { outcome: "NOTHING_RUNNING" };
+    }
+    catch (err) {
+        return { outcome: "UNREACHABLE", reason: `the pane could not be read: ${errText(err)}` };
+    }
+    try {
+        // A KEY NAME, deliberately without `-l`; and no Enter.
+        await exec("tmux", ["-S", handle.socket, "send-keys", "-t", handle.pane, key]);
+    }
+    catch (err) {
+        return { outcome: "FAILED", reason: `tmux refused the key: ${errText(err)}` };
+    }
+    await sleep(AFTER_KEY_MS);
+    try {
+        return isBusy(runtime, await capture(handle)) ? { outcome: "FAILED", reason: "it is still working" } : { outcome: "DONE" };
+    }
+    catch (err) {
+        return { outcome: "FAILED", reason: `the pane could not be read after the key: ${errText(err)}` };
+    }
+}
+function capturePane(handle) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)("tmux", ["-S", handle.socket, "capture-pane", "-p", "-t", handle.pane], { timeout: 5_000, encoding: "utf8" }, (err, out) => err ? reject(err) : resolve(String(out)));
+    });
+}
+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/session-commands.js

@@ -29,7 +29,7 @@ exports.SESSION_COMMANDS = [
     { id: "mode-read", trigger: "/mode-read", mode: "read", summary: "Relay-run agents: may read files, no commands, no writes. Owner or anyone with command access." },
     { id: "mode-ask", trigger: "/mode-ask", mode: "ask", summary: "Relay-run agents: may run commands; writes ask on your phone first. Owner or anyone with command access." },
     { id: "mode-full", trigger: "/mode-full", mode: "full", summary: "Relay-run agents: may write inside its folder without asking. Owner or anyone with command access." },
-    { id: "stop", trigger: "/stop", summary: "Relay-run agents: stop the turn that is running now." },
+    { id: "stop", trigger: "/stop", summary: "Stop the turn that is running now (its owner; a terminal session needs tmux)." },
     {
         id: "exit",
         trigger: "/exit",

package/dist/relay/terminal-stop.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTerminalStop = runTerminalStop;
+const pane_interrupt_1 = require("./pane-interrupt");
+/**
+ * `/stop` for a session running in someone's own terminal (AGENT_STOP_UNDO.md §2) — what the app's
+ * Stop button sends, and what the owner may type in a chat.
+ *
+ * OWNER ONLY. Stop is a keystroke into a terminal on the owner's own computer; a person she granted
+ * command access may tidy a session, never stop it (§2.2). `senderIsOwner` is decided by the server
+ * at hand-over, so this is the second check after the app's route.
+ *
+ * One interrupt (`interruptPane`: two looks, one Escape, one look after) and one reply that says what
+ * the pane showed. Relay-run sessions (ACP, Codex) keep their own `/stop`; this is only reached for a
+ * session in a terminal.
+ */
+async function runTerminalStop(session, target, message, say, deps = {}) {
+    if (message.senderIsOwner !== true) {
+        await say(`Only the owner of "${session}" can stop it.`);
+        return;
+    }
+    if (!target.pane) {
+        await say(`"${session}" isn't in a tmux terminal, so BayChat can't stop it. Stop it in its own terminal.`);
+        return;
+    }
+    const interrupt = deps.interrupt ?? ((handle, runtime, opts) => (0, pane_interrupt_1.interruptPane)(handle, runtime, opts));
+    const result = await interrupt(target.pane, target.runtime, { ownerPid: target.ownerPid });
+    await say(stopReply(session, result));
+}
+function stopReply(session, result) {
+    switch (result.outcome) {
+        case "DONE":
+            return `Stopped "${session}". It is waiting for you; anything it already did stays done.`;
+        case "NOTHING_RUNNING":
+            return `"${session}" was not working on anything, so nothing was sent.`;
+        case "FAILED":
+            return `"${session}" did not stop (${result.reason ?? "it is still working"}). Stop it in its own terminal.`;
+        default:
+            return `"${session}" can't be stopped from BayChat (${result.reason ?? "its terminal can't be reached"}). Stop it in its own terminal.`;
+    }
+}

package/dist/relay/updates.js

@@ -22,11 +22,13 @@ const project_notes_1 = require("./project-notes");
  *     app offers it, and BayChat starts one itself, only while every polling relay says so.
  *   - `notice`: it shows sessions BayChat's 90% memory notice (context-notice.ts, protocol 1.17),
  *     so it may be handed it — and have it marked sent.
+ *   - `interrupt`: its `/stop` reaches a session in a tmux terminal too (terminal-stop.ts: owner
+ *     only, one Escape) — the app offers Stop only while every polling relay says so.
  *
  * ONE list for every door: this long-poll's query, the WebSocket `hello` (ws.ts splits this same
  * string) and so the device feed's feature record.
  */
-exports.RELAY_FEATURES = "brief,compact,freshstart,notes,notice";
+exports.RELAY_FEATURES = "brief,compact,freshstart,notes,notice,interrupt";
 /** Server clamps `wait` into [1s, 30s]; 25s stays under the usual 60s proxy idle timeout. */
 const WAIT_SECONDS = 25;
 /** Backoff bounds for transient failures (5xx, 429, network). */

package/dist/setup-command.js

@@ -0,0 +1,126 @@
+"use strict";
+// `npx baychat` and `baychat setup` — ONE COMMAND (Karmen + Lorenzo, 31 Oct 2026; plan in BAYCHAT, vps-reviewed).
+//
+// Bare `baychat`: the first time (no "set up" mark yet), sign in once and set up every agent app found (setup-plan.ts),
+// print one checklist, then start a session — only inside a project (vps: never in the home folder, where a session
+// could read and write everything). Once set up, bare `baychat` goes straight to the start, as before, without asking
+// every app again. `baychat setup` always looks again (after installing a new app).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetup = runSetup;
+exports.runBare = runBare;
+exports.runSetupCommand = runSetupCommand;
+exports.setupMarkPath = setupMarkPath;
+exports.realSetupDeps = realSetupDeps;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const commands_1 = require("./commands");
+const connect_1 = require("./connect");
+const connect_claude_1 = require("./connect-claude");
+const doctor_1 = require("./doctor");
+const doctor_command_1 = require("./doctor-command");
+const machine_name_1 = require("./machine-name");
+const multiplexer_launch_1 = require("./multiplexer-launch");
+const setup_facts_1 = require("./setup-facts");
+const start_command_1 = require("./start-command");
+const setup_plan_1 = require("./setup-plan");
+/** Look, set up what is missing, and say what is ready. Returns 2 when the login was not approved. */
+async function runSetup(deps) {
+    const facts = await deps.facts();
+    const steps = (0, setup_plan_1.planSetup)(facts);
+    const done = new Set();
+    const failed = new Set();
+    for (const step of steps) {
+        if (step.kind === "login") {
+            deps.log("Sign this computer in to BayChat (once): scan the code with the BayChat app.");
+            if (!(await deps.login()))
+                return 2;
+            continue;
+        }
+        deps.log(`Setting up ${step.client}…`);
+        if ((await deps.connect(step.client)) === 0)
+            done.add(step.client);
+        else
+            failed.add(step.client);
+    }
+    deps.log("");
+    for (const line of (0, setup_plan_1.setupChecklist)(facts, { done, failed }))
+        deps.log(`  ${line}`);
+    deps.markSetUp();
+    return 0;
+}
+/**
+ * Bare `baychat`: set up the first time, then start — in a project only. Once set up, a project starts straight away;
+ * any other folder (the home folder above all) asks first, default no (vps, 31 Oct: nobody gives an agent all of home
+ * by accident).
+ */
+async function runBare(deps) {
+    if (deps.wasSetUp()) {
+        if (deps.inProject())
+            return deps.start();
+        if (await deps.confirm("This isn't a project folder. Start a session here anyway? (y/N) "))
+            return deps.start();
+        deps.log("  Not started. cd into a project and run npx baychat again (or start a session from the BayChat app).");
+        return 0;
+    }
+    const code = await runSetup(deps);
+    if (code !== 0)
+        return code;
+    return startOrPoint(deps);
+}
+/** `baychat setup`: always look again; start only when asked to and in a project. */
+async function runSetupCommand(deps) {
+    const code = await runSetup(deps);
+    if (code !== 0)
+        return code;
+    deps.log("");
+    deps.log("  Next: run npx baychat in a project folder to start a session (or start one from the BayChat app).");
+    return 0;
+}
+async function startOrPoint(deps) {
+    deps.log("");
+    if (deps.inProject())
+        return deps.start();
+    deps.log("  Next: cd into a project and run npx baychat again (or start a session from the BayChat app).");
+    return 0;
+}
+/** Where the "set up" mark lives: beside the credentials, removed with them. */
+function setupMarkPath() {
+    return path_1.default.join((0, config_1.configDir)(), "setup-done.json");
+}
+/** The real dependencies. `wsl` only for tests: a test run inside WSL still exercises the Claude Desktop path. */
+function realSetupDeps(over = {}) {
+    const exists = (p) => fs_1.default.existsSync(p);
+    return {
+        facts: async () => {
+            const env = await (0, doctor_command_1.currentDoctorEnv)();
+            return (0, setup_facts_1.setupFactsFrom)(env, (0, doctor_1.buildReport)(env), { wsl: over.wsl ?? (0, machine_name_1.isWsl)(), exists });
+        },
+        login: () => (0, commands_1.cmdLogin)({ registerClaude: false, hint: false }),
+        connect: (client) => (client === "claude" ? (0, connect_claude_1.cmdConnectClaude)({}) : (0, connect_1.cmdConnect)(client, {})),
+        start: () => (0, start_command_1.cmdStart)([]),
+        inProject: () => (0, setup_plan_1.isProjectDir)(process.cwd(), exists, os_1.default.homedir()),
+        confirm: async (question) => {
+            if (!process.stdin.isTTY)
+                return false;
+            return /^y(es)?$/i.test((await (0, multiplexer_launch_1.askLine)(question)).trim());
+        },
+        // Signed out since (or the credentials were removed): look again, which signs in.
+        wasSetUp: () => exists(setupMarkPath()) && (0, config_1.loadDeviceCredentials)() !== null,
+        markSetUp: () => {
+            try {
+                fs_1.default.mkdirSync(path_1.default.dirname(setupMarkPath()), { recursive: true });
+                fs_1.default.writeFileSync(setupMarkPath(), JSON.stringify({ at: new Date().toISOString() }) + "\n");
+            }
+            catch (err) {
+                // Only costs a second look next time.
+                console.warn(`Could not record that setup is done: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        },
+        log: (line) => console.log(line),
+    };
+}

package/dist/setup-facts.js

@@ -0,0 +1,44 @@
+"use strict";
+// The facts `planSetup` decides from, read off this computer through what `baychat doctor` already knows: its report
+// says whether BayChat is in each app (it asks `claude mcp list` / `codex mcp list` themselves, and reads every file
+// Claude Desktop or Cursor may open), and its binary resolver says what is installed. Nothing new is guessed here.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configuredFrom = configuredFrom;
+exports.installedFrom = installedFrom;
+exports.setupFactsFrom = setupFactsFrom;
+const path_1 = __importDefault(require("path"));
+const client_paths_1 = require("./client-paths");
+const setup_plan_1 = require("./setup-plan");
+/** Is BayChat in this app already? Doctor's MCP check passes for it (an unknown answer counts as no: connect again). */
+function configuredFrom(report) {
+    const out = {};
+    for (const client of setup_plan_1.SETUP_CLIENTS) {
+        const runtime = report.runtimes.find((r) => r.runtime === client);
+        out[client] = Boolean(runtime?.checks.some((c) => c.name === "mcp" && c.status === "pass"));
+    }
+    return out;
+}
+/** Is the app on this computer? A CLI is a resolvable binary; a GUI app is the folder its config lives in. */
+function installedFrom(env, exists) {
+    const pathEnv = env.pathEnv ?? { home: env.home, platform: env.platform };
+    return {
+        claude: env.resolveBinary("claude").ok,
+        desktop: (0, client_paths_1.configPathsFor)("desktop", pathEnv).some((file) => exists((0, client_paths_1.configDirOf)(file))),
+        codex: env.resolveBinary("codex").ok || exists(path_1.default.join(pathEnv.codexHome ?? path_1.default.join(env.home, ".codex"))),
+        cursor: exists(path_1.default.join(env.home, ".cursor")) || env.resolveBinary("cursor-agent").ok,
+    };
+}
+/** Every fact `planSetup` needs. */
+function setupFactsFrom(env, report, host) {
+    const expires = env.device ? Date.parse(env.device.expiresAt) : NaN;
+    return {
+        signedIn: env.device !== null && Number.isFinite(expires) && expires > env.now,
+        installed: installedFrom(env, host.exists),
+        configured: configuredFrom(report),
+        wsl: host.wsl,
+        hermesFound: env.resolveBinary("hermes").ok || host.exists(path_1.default.join(env.home, ".hermes")),
+    };
+}

package/dist/setup-plan.js

@@ -0,0 +1,94 @@
+"use strict";
+// What `npx baychat` (and `baychat setup`) should DO, decided before anything is done.
+//
+// ONE COMMAND (Karmen + Lorenzo, 31 Oct 2026): people did not know which of `login`, `connect desktop`,
+// `connect codex`… was theirs. Now the one line signs this computer in ONCE (the phone QR) and sets up every agent
+// app it finds that is not set up yet — through the very same `connect` paths, so nothing new is written anywhere.
+// Hermes is named, not set up: it gets an agent of its own, chosen on the phone (a second QR), which is not "one".
+//
+// Facts in, steps out — like `connect-plan.ts` — so the order is testable without a phone, a network or the apps.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETUP_CLIENTS = void 0;
+exports.planSetup = planSetup;
+exports.setupChecklist = setupChecklist;
+exports.isProjectDir = isProjectDir;
+/** The apps one command sets up, in the order it does them. */
+exports.SETUP_CLIENTS = ["claude", "desktop", "codex", "cursor"];
+const LABELS = {
+    claude: "Claude Code",
+    desktop: "Claude Desktop",
+    codex: "Codex",
+    cursor: "Cursor",
+};
+/** The steps: the one login when there is none, then every app found and not yet set up. */
+function planSetup(facts) {
+    const steps = facts.signedIn ? [] : [{ kind: "login" }];
+    for (const client of exports.SETUP_CLIENTS) {
+        if (client === "desktop" && facts.wsl)
+            continue;
+        if (facts.installed[client] && !facts.configured[client])
+            steps.push({ kind: "connect", client });
+    }
+    return steps;
+}
+/** The closing list, one line per app: ready, set up now, not here, or not finished (with what to run). */
+function setupChecklist(facts, outcome) {
+    const lines = exports.SETUP_CLIENTS.map((client) => {
+        const label = LABELS[client];
+        if (client === "desktop" && facts.wsl)
+            return `– ${label} (it runs on Windows: run npx baychat once in Windows PowerShell)`;
+        if (outcome.failed.has(client))
+            return `✗ ${label} (did not finish; run npx baychat connect ${client})`;
+        if (outcome.done.has(client))
+            return client === "desktop" ? `✓ ${label} (just set up; restart it once)` : `✓ ${label} (just set up)`;
+        if (facts.configured[client])
+            return `✓ ${label}`;
+        return `– ${label} (not on this computer)`;
+    });
+    if (facts.hermesFound)
+        lines.push("• Hermes found: npx baychat connect hermes (it gets its own agent, chosen on your phone)");
+    return lines;
+}
+/** Files that make a folder a project worth starting an agent in. */
+const PROJECT_MARKERS = [
+    "package.json",
+    "pyproject.toml",
+    "requirements.txt",
+    "Cargo.toml",
+    "go.mod",
+    "Gemfile",
+    "pom.xml",
+    "build.gradle",
+    "composer.json",
+    "deno.json",
+    "Package.swift",
+    "mix.exs",
+];
+/**
+ * May a session start here? vps, 31 Oct: a first-time user often runs `npx baychat` in the home folder, and a session
+ * started there can read and write all of it. So only in a project: a folder with a project file, or inside a git
+ * repository (found by walking up, stopping BEFORE the home folder). The home folder itself never counts.
+ */
+function isProjectDir(cwd, exists, home) {
+    const sep = cwd.includes("\\") && !cwd.includes("/") ? "\\" : "/";
+    const trim = (p) => (p.length > 1 && (p.endsWith("/") || p.endsWith("\\")) ? p.slice(0, -1) : p);
+    const here = trim(cwd);
+    const stop = trim(home);
+    if (here === stop)
+        return false;
+    const join = (dir, name) => `${dir}${sep}${name}`;
+    if (PROJECT_MARKERS.some((marker) => exists(join(here, marker))))
+        return true;
+    for (let dir = here; dir !== stop;) {
+        if (exists(join(dir, ".git")))
+            return true;
+        const cut = dir.lastIndexOf(sep);
+        if (cut <= 0 || dir.slice(0, cut) === dir)
+            break;
+        const parent = dir.slice(0, cut);
+        if (parent.length < stop.length)
+            break;
+        dir = parent;
+    }
+    return false;
+}

package/dist/start-command.js

@@ -95,7 +95,7 @@ function startRefusal(runtime) {
 }
 async function cmdStart(args) {
     if (!(0, config_1.loadDeviceCredentials)()) {
-        console.error("This machine is not signed in yet. Run `npx baychat login` first.");
+        console.error("This machine is not signed in yet. Run `npx baychat` first: it signs in and sets up your agent apps.");
         return 1;
     }
     // THE UPDATE NOBODY HAS TO REMEMBER.

package/dist/tool-defs.js

@@ -224,8 +224,8 @@ exports.CONVERSATION_TOOL_DEFS = [
             "acknowledge (react instead). Be concise; @mention a person only when you need them (it " +
             "reaches them even if muted). Answering a specific message: pass replyToMessageId, which " +
             "quotes it and marks it ✅ for you (a progress update: done=false). To relay a " +
-            "calendar event or an email pass `card`, with `content` as a one-line plain-text fallback. " +
-            "Decisions go through request_approval, not here.",
+            "calendar event or an email, or to show a chart or a page, pass `card`, with `content` as a one-line " +
+            "plain-text fallback. Decisions go through request_approval, not here.",
         inputSchema: {
             conversationId: zod_1.z.string().describe(CONVERSATION_ID),
             content: zod_1.z.string().describe("Message text."),
@@ -255,13 +255,17 @@ exports.CONVERSATION_TOOL_DEFS = [
                 .describe("Ids of files you already uploaded, attached in order."),
             card: zod_1.z
                 .object({
-                type: zod_1.z.enum(["card.calendar", "card.email"]),
+                type: zod_1.z.enum(["card.calendar", "card.email", "card.chart", "card.page"]),
                 payload: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
             })
                 .optional()
                 .describe("Render as a card. card.calendar: title, start, end (ISO 8601), location, attendees " +
                 "[{name,address}], notes. card.email: subject, from {name,address} (display only), " +
-                "snippet, body, timestamp. A card OR attachments, never both."),
+                "snippet, body, timestamp. card.chart: title, kind bar|line, labels[2-31], " +
+                "series[1-3]{name?, values[] (one per label), highlight?[] (indexes)}, unit?, note?, " +
+                "key? (same key again = its next version, v2). Data only: BayChat draws it. " +
+                "card.page: title, body (markdown, ≤20,000 chars; no HTML, images show as links), key?. " +
+                "A card OR attachments, never both."),
         },
         _meta: exports.ALWAYS_LOAD_META,
     },