baychat 0.37.0 → 0.39.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "displayName": "BayChat",
   "description": "Wakes this Claude Code session the moment a BayChat message arrives: no Monitor, no 30-minute deadline. Uses the baychat CLI already on this computer (npm install -g baychat, then baychat login).",
   "author": {

package/README.md

@@ -6,15 +6,20 @@
 
 **The BayChat connector.** Bring Claude Code, Codex, Cursor or an agent you built yourself into one
 group chat with you and your team. Your agents work together, ask before they act, and wait for your
-answer, from your phone if you're out. [baychat.io](https://baychat.io) · free with three agents.
+answer, from your phone if you're out. [baychat.io](https://baychat.io) · free with one agent.
 
-## Connect an agent in one line
+## One command
 
 ```bash
-npx baychat connect claude     # Claude Code   (also: codex · cursor · desktop)
+npx baychat
 ```
 
-The first time, it shows a QR: approve it in the BayChat app and this computer is yours. Then, inside
+The first time, it shows a QR: approve it in the BayChat app and this computer is yours. Then it sets up
+every agent app it finds on this computer (Claude Code, Claude Desktop, Codex, Cursor), lists what is
+ready, and starts a session when you run it inside a project folder. After that, `npx baychat` just starts
+a session. Installed another app later? `npx baychat setup` looks again.
+
+One app at a time still works: `npx baychat connect claude` (also `codex` · `cursor` · `desktop`). Inside
 Claude Code, join a room with `/baychat Scout "Launch week"`.
 
 **Your own agent**, anything that can run a shell command: in the app, *Add agent → Any agent via the CLI*

package/dist/approval-wait.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.askOwnerAndWait = askOwnerAndWait;
+exports.waitOnOwnerQuestion = waitOnOwnerQuestion;
 exports.withdrawOwnerQuestion = withdrawOwnerQuestion;
 exports.reasonOf = reasonOf;
 // Asking this machine's owner a decision card, and waiting for the tap.
@@ -114,6 +115,19 @@ async function waitForAnswer(device, requestId, first, deadlineMs, deps, label)
         }
     }
 }
+/**
+ * Park on a card that already exists until it is answered, withdrawn, unreachable or past
+ * `deadlineMs` — the re-arm half of `askOwnerAndWait`, for a waiter that checks something else
+ * between windows (notify-answer.ts looks at the terminal). NEVER THROWS.
+ */
+async function waitOnOwnerQuestion(device, requestId, deadlineMs, deps, label) {
+    try {
+        return await waitForAnswer(device, requestId, { status: "waiting" }, deadlineMs, deps, label);
+    }
+    catch (err) {
+        return { kind: "failed", reason: `waiting for BayChat failed unexpectedly — ${reasonOf(err)}` };
+    }
+}
 /**
  * Take back a card nobody will act on any more (the waiting process is about to give up). Best
  * effort and NEVER THROWS: a card left pending is harmless — the answer would reach nobody — so

package/dist/approve-hook.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CLAUDE_HOPS = exports.readStdin = exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
+exports.LINK_LOST_NOTICE = exports.MAX_CLAUDE_HOPS = exports.readStdin = exports.APPROVE_OPTIONS = exports.RECOMMENDED_HANDLER_TIMEOUT_SECONDS = exports.DEFAULT_WAIT_SECONDS = void 0;
 exports.allowDecision = allowDecision;
 exports.denyDecision = denyDecision;
 exports.describeToolRequest = describeToolRequest;
@@ -47,6 +47,7 @@ exports.psParentOf = psParentOf;
 exports.psAgeMs = psAgeMs;
 exports.parseEtime = parseEtime;
 exports.decideApprovalOrDefer = decideApprovalOrDefer;
+exports.noDecisionNotice = noDecisionNotice;
 exports.cmdApproveHook = cmdApproveHook;
 // `baychat approve-hook` — the Claude Code PermissionRequest hook that moves a terminal
 // permission prompt onto a phone, as a card in the owner's private chat with the session.
@@ -89,7 +90,8 @@ exports.cmdApproveHook = cmdApproveHook;
 // THE ONE EXCEPTION: `--session-from-claude` before the session has joined. `baychat claude` and
 // `baychat start` install this hook before the session has a name; until the channel records the
 // name (channel/claude-link.ts) there is no session a card could belong to. Then — and only then —
-// this prints NOTHING and exits 0, and Claude Code shows its own terminal dialog. That is not an
+// this prints no decision and exits 0, and Claude Code shows its own terminal dialog (in a channel
+// session that lost its link, with a `systemMessage` saying why: `noDecisionNotice`). That is not an
 // allow: it is the ordinary permission prompt, answered by the person who just ran the command at
 // that very terminal. Every other path, including every failure once a session WAS found, still
 // ends in an explicit decision.
@@ -104,7 +106,9 @@ const approval_wait_1 = require("./approval-wait");
 const config_1 = require("./config");
 const hook_stdin_1 = require("./hook-stdin");
 const claude_link_1 = require("./channel/claude-link");
+const detect_1 = require("./channel/detect");
 const compound_command_1 = require("./denied/compound-command");
+const notify_state_1 = require("./notify-state");
 function allowDecision() {
     return {
         hookSpecificOutput: {
@@ -166,6 +170,17 @@ function str(value) {
 function clip(text, max) {
     return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
+/** `https://claude.ai/artifact/abc?x=1` → `claude.ai/artifact`; not a URL → "". */
+function pageOf(url) {
+    try {
+        const u = new URL(url);
+        const first = u.pathname.split("/").find(Boolean);
+        return first ? `${u.host}/${first}` : u.host;
+    }
+    catch {
+        return "";
+    }
+}
 /**
  * What this tool call would actually do, in the words the person on the phone needs.
  *
@@ -197,6 +212,18 @@ function describeToolRequest(toolName, toolInput) {
                 return str(input.url);
             case "WebSearch":
                 return str(input.query);
+            case "Artifact": {
+                // A shared page names itself by host and first path part only (vps, 29 Oct): enough to tell
+                // which page; a query string or the rest of the path can carry a key.
+                const action = str(input.action) || "use";
+                const url = str(input.url);
+                if (url) {
+                    const page = pageOf(url);
+                    return action === "read" ? (page ? `read the shared page ${page}` : "read a shared page") : `${action} ${page || "a shared page"}`;
+                }
+                const file = str(input.file_path);
+                return file ? `${action} ${file}` : action;
+            }
             default:
                 return "";
         }
@@ -299,7 +326,17 @@ async function decideApproval(rawStdin, argv = [], deps = {}) {
         // The card goes to the private chat between this session and its owner, and the wait
         // re-arms across bounded holds until somebody taps (approval-wait.ts). Every outcome that is
         // not "answered with index 0" becomes a deny below.
-        const outcome = await (0, approval_wait_1.askOwnerAndWait)(device, { session: opts.session, question, options: [...exports.APPROVE_OPTIONS] }, deadline, { now, sleep, log }, "baychat approve-hook");
+        // While the card is on the phone, notify-hook stays quiet for this session: one prompt, one
+        // thing on the phone (notify-state.ts).
+        const claudeSession = str(input.session_id);
+        (0, notify_state_1.markCardPending)(claudeSession);
+        let outcome;
+        try {
+            outcome = await (0, approval_wait_1.askOwnerAndWait)(device, { session: opts.session, question, options: [...exports.APPROVE_OPTIONS] }, deadline, { now, sleep, log }, "baychat approve-hook");
+        }
+        finally {
+            (0, notify_state_1.clearCardPending)(claudeSession);
+        }
         return verdictOf(outcome, opts.waitSeconds, isChained(toolName, input.tool_input));
     }
     catch (err) {
@@ -448,13 +485,29 @@ async function decideApprovalOrDefer(rawStdin, argv = [], deps = {}) {
         return null;
     return decideApproval(rawStdin, ["--session", session, ...rest], deps);
 }
+/**
+ * What a hook with NO decision tells the person at the terminal (Branding, 29 Oct): a session
+ * started with BayChat's channel whose link is gone (claude-link.ts) still asks in the terminal,
+ * but now says why its question never reached the phone and what fixes it. A session that never
+ * joined BayChat's channel says nothing, as before. `systemMessage` only: no decision object, so
+ * Claude Code's own dialog still asks — never an allow by this code. Never throws.
+ */
+exports.LINK_LOST_NOTICE = "BayChat can't reach your phone for this question: the session lost its link. Answer here, then type: re-listen to BayChat";
+function noDecisionNotice(deps = {}) {
+    try {
+        return (deps.detect ?? (() => (0, detect_1.detectChannel)()))().active ? { systemMessage: exports.LINK_LOST_NOTICE } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * `baychat approve-hook [--session <name> | --session-from-claude] [--timeout <seconds>]`
  *
  * Always returns 0. A non-zero exit is a non-blocking error to Claude Code, which means the tool
  * call PROCEEDS — so exiting 1 on failure would be precisely backwards.
  */
-async function cmdApproveHook(argv = [], stdin = process.stdin) {
+async function cmdApproveHook(argv = [], stdin = process.stdin, deps = {}) {
     let decision;
     try {
         decision = await decideApprovalOrDefer(await (0, hook_stdin_1.readStdin)(stdin), argv);
@@ -465,10 +518,15 @@ async function cmdApproveHook(argv = [], stdin = process.stdin) {
         process.stderr.write(`baychat approve-hook: ${err instanceof Error ? err.message : String(err)}\n`);
         decision = denyClosed("the approval gate could not run");
     }
-    // No decision: `--session-from-claude` before the session joined — Claude Code's own dialog.
-    if (decision === null)
+    // No decision: `--session-from-claude` with no session found — Claude Code's own dialog, plus a
+    // line saying why when this is a channel session that lost its link.
+    if (decision === null) {
+        const notice = noDecisionNotice(deps);
+        if (notice)
+            process.stdout.write(`${JSON.stringify(notice)}\n`);
         return 0;
-    // The single write to stdout, and the only one in this file.
+    }
+    // The decision's write to stdout (the notice above is the only other, and carries no decision).
     process.stdout.write(`${JSON.stringify(decision)}\n`);
     return 0;
 }

package/dist/cli-help.js

@@ -19,10 +19,15 @@ Exit 0: step succeeded; 2: awaiting approval or expired; 1: error.
 exports.HELP = `baychat — BayChat connector CLI for agent sessions (Claude Code, Codex)
 
 Usage:
-  baychat                               Start a session. This is the whole thing: it runs
-                                        your agent somewhere BayChat can reach, so /clear
-                                        and /new from the app work. Sign in once with
-                                        \`baychat login\` first
+  baychat                               Start a session: the one command. The first time it
+                                        signs this computer in (one QR on your phone) and sets
+                                        up every agent app it finds — Claude Code, Claude
+                                        Desktop, Codex, Cursor — then starts a session if you
+                                        are in a project folder. After that it just starts a
+                                        session, somewhere BayChat can reach, so /clear and
+                                        /new from the app work
+  baychat setup                         Look again and set up any agent app installed since;
+                                        starts nothing
   baychat start [name] [--runtime <runtime>]
                                         Start a session (what bare \`baychat\` does), with
                                         a name for it
@@ -174,6 +179,11 @@ Usage:
                                         project's .claude/settings.local.json and let
                                         the session retry. Prints the retry or nothing;
                                         every error leaves the denial standing
+  baychat notify-hook [--dry-run]       Claude Code Notification hook (the plugin's): when a
+                                        permission dialog or an MCP form waits in a
+                                        terminal, put one line on your phone saying which
+                                        session waits and on what. Watch-only; prints
+                                        nothing. --dry-run: the line to stderr instead
   baychat permissions [list | remove <id> | on | off]
                                         The denied-command card: on/off for sessions
                                         BayChat starts (OFF by default), and the rules
@@ -226,7 +236,7 @@ function helpRequest(command, args) {
  * - `claude` passes every argument to Claude Code — `baychat claude --help` is Claude Code's help;
  * - `send` and `search` take free text, which may say "--help";
  * - `approve-hook` must write exactly one decision object to stdout, whatever it is given, and
- *   `denied-hook` / `denied-after` must never print help where Claude Code reads a hook's output;
+ *   `denied-hook` / `denied-after` / `notify-hook` must never print help where Claude Code reads a hook's output;
  * - `help` (and its spellings) already prints help, and its arguments are a question.
  */
 const ARGS_ARE_NOT_OURS = new Set([
@@ -236,6 +246,8 @@ const ARGS_ARE_NOT_OURS = new Set([
     "approve-hook",
     "denied-hook",
     "denied-after",
+    "notify-hook",
+    "notify-answer",
     "help",
     "--help",
     "-h",

package/dist/main.js

@@ -7,8 +7,11 @@ const denied_hook_1 = require("./denied-hook");
 const permissions_command_1 = require("./permissions-command");
 const context_hooks_command_1 = require("./context-hooks-command");
 const channel_check_1 = require("./channel/channel-check");
+const notify_hook_1 = require("./notify-hook");
+const notify_answer_1 = require("./notify-answer");
 const session_name_1 = require("./session-name");
 const start_command_1 = require("./start-command");
+const setup_command_1 = require("./setup-command");
 const update_command_1 = require("./update-command");
 const notice_1 = require("./auto-update/notice");
 const session_command_1 = require("./session-command");
@@ -56,13 +59,14 @@ function numberFlag(args, name) {
 }
 async function main() {
     const [command, ...args] = process.argv.slice(2);
-    // BARE `baychat` STARTS A SESSION. The bar is "download BayChat, start a session, nothing
-    // else", and a usage dump printed at somebody who typed the product's own name is the
-    // "something else". `--help` still prints the help, and `start` refuses with one sentence
-    // when this machine is not signed in, so nothing is launched from an unusable state.
+    // BARE `baychat` IS THE ONE COMMAND (31 Oct 2026, setup-command.ts). The first time it signs this
+    // computer in once and sets up every agent app it finds, then starts a session — only inside a
+    // project, never in the home folder. Once set up it starts straight away, as it always did. A usage
+    // dump printed at somebody who typed the product's own name would be "something else"; `--help`
+    // still prints the help.
     if (command === undefined) {
         (0, notice_1.printUpdateNotice)(command);
-        return (0, start_command_1.cmdStart)([]);
+        return (0, setup_command_1.runBare)((0, setup_command_1.realSetupDeps)());
     }
     // "BayChat updated itself to …": the relay's one line for the terminal, shown once, on a command
     // a person typed (never into a hook's or an MCP server's output).
@@ -83,6 +87,10 @@ async function main() {
             return (0, session_command_1.cmdJoinSession)(args);
         case "start":
             return (0, start_command_1.cmdStart)(args);
+        case "setup":
+            // Look again and set up what is new (an app installed since); starts nothing.
+            (0, args_1.rejectUnknownFlags)(args, [], "baychat setup");
+            return (0, setup_command_1.runSetupCommand)((0, setup_command_1.realSetupDeps)());
         case "update":
             // `--quiet` is how an old version hands a `start`-driven update to the new one.
             (0, args_1.rejectUnknownFlags)(args, ["--quiet", "--auto"], "baychat update [--auto on|off]");
@@ -338,6 +346,13 @@ async function main() {
             return await (0, permissions_command_1.cmdPermissions)(args);
         case "context-hooks":
             return await (0, context_hooks_command_1.cmdContextHooks)(args);
+        case "notify-hook":
+            // The plugin's Notification hook: a question stuck in the terminal → one line on the owner's
+            // phone. Never throws, always 0, prints nothing (notify-hook.ts).
+            return await (0, notify_hook_1.cmdNotifyHook)(args);
+        case "notify-answer":
+            // Started detached by notify-hook: answers one terminal dialog from the phone (notify-answer.ts).
+            return await (0, notify_answer_1.cmdNotifyAnswer)(args);
         case "channel-check":
             // The plugin's SessionStart (compact) hook. Never throws, always 0 (channel/channel-check.ts).
             return await (0, channel_check_1.cmdChannelCheck)();

package/dist/notify-answer.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETTLE_MS = exports.ANSWER_DEADLINE_MS = void 0;
+exports.readDialog = readDialog;
+exports.answerFromPhone = answerFromPhone;
+exports.paneAnswerDeps = paneAnswerDeps;
+exports.cmdNotifyAnswer = cmdNotifyAnswer;
+// `baychat notify-answer` — answering a terminal dialog from the phone (vps, 29 Oct: "the keys").
+//
+// notify-hook starts this, detached, when the stuck question is in a session BayChat knows (its
+// claude-sessions link) running in a tmux pane, and the pane shows a numbered dialog. It puts the
+// dialog's own question and answers on a card in the session's private chat with its owner, and
+// on a tap presses that ONE number in the pane — measured on the real dialog (29 Oct): a digit
+// selects and confirms, no Enter.
+//
+// THE RULE THE WHOLE THING RESTS ON: a key is pressed only while `capture-pane` still shows THE
+// SAME question. A `1` landing in an ordinary input line would be typed as text and sent as a
+// message. So the pane is read again right before the key; a different screen sends nothing and
+// says "already answered in the terminal". While waiting, the pane is looked at between windows:
+// answered at the keyboard first → the card is taken back. Keys: the digits of the dialog's own
+// options and nothing else — never text, never Enter, never a key a message could name. The card
+// is answerable by the owner only (the device credential's own user), and the pane must still be
+// running Claude Code (`verifyPane`).
+const child_process_1 = require("child_process");
+const api_1 = require("./api");
+const approval_wait_1 = require("./approval-wait");
+const config_1 = require("./config");
+const terminal_pane_1 = require("./relay/terminal-pane");
+/** How long the phone may take: the same hour a permission card waits. */
+exports.ANSWER_DEADLINE_MS = 60 * 60_000;
+/** One wait on the card between looks at the terminal. */
+const WINDOW_MS = 20_000;
+/** A breath between looks, so a card answered and a screen changing at the same moment settle. */
+const GAP_MS = 1_000;
+/**
+ * Between the two looks right before a key. Found on the real dialog (29 Oct): a screen read just
+ * after a key can still show the old dialog, and a `1` then landed in the input line.
+ */
+exports.SETTLE_MS = 700;
+const OPTION = /^\s*(?:❯\s*)?([1-9])\.\s+(\S.*?)\s*$/;
+const DECORATION = /^[\s│╌─━┃┄┈|]*$/;
+/**
+ * The open dialog on a captured screen, or undefined. A dialog is a run of options numbered from
+ * 1 with "Esc to cancel" right under it, and the question is the nearest line above ending in "?"
+ * (a conversation's own numbered list has no "Esc to cancel" under it, so it is never one).
+ */
+function readDialog(screen) {
+    const lines = screen.split("\n");
+    for (let end = lines.length - 1; end >= 0; end--) {
+        if (!/Esc to cancel/.test(lines[end]))
+            continue;
+        // The options: the numbered run directly above "Esc to cancel".
+        const options = [];
+        let i = end - 1;
+        while (i >= 0 && DECORATION.test(lines[i]) && lines[i].trim() === "")
+            i--;
+        let first = i;
+        while (i >= 0 && OPTION.test(lines[i])) {
+            first = i;
+            i--;
+        }
+        for (let k = first; k < end; k++) {
+            const m = OPTION.exec(lines[k]);
+            if (m)
+                options.push(m[2]);
+        }
+        if (options.length === 0)
+            return undefined;
+        // In order from 1: "1. …", "2. …".
+        for (let k = first, n = 1; k < end; k++) {
+            const m = OPTION.exec(lines[k]);
+            if (!m)
+                continue;
+            if (Number(m[1]) !== n++)
+                return undefined;
+        }
+        for (let q = first - 1; q >= Math.max(0, first - 15); q--) {
+            const text = lines[q].trim();
+            if (text.endsWith("?") && !text.startsWith("│"))
+                return { question: text, options };
+        }
+        return undefined;
+    }
+    return undefined;
+}
+const sameDialog = (screen, dialog) => readDialog(screen)?.question === dialog.question;
+/**
+ * One dialog, answered from the phone or left to the terminal. Returns what happened, for the log.
+ * NEVER THROWS (a failing capture counts as "the dialog is gone": send nothing).
+ */
+async function answerFromPhone(run, deps) {
+    const { session, dialog } = run;
+    const capture = async () => {
+        try {
+            return await deps.capture();
+        }
+        catch {
+            return "";
+        }
+    };
+    const until = deps.now() + exports.ANSWER_DEADLINE_MS;
+    let outcome = await deps.ask({ session, question: `${session} is waiting on a question in its terminal:\n${dialog.question}`, options: dialog.options }, Math.min(until, deps.now() + WINDOW_MS));
+    for (;;) {
+        if (outcome.kind === "answered") {
+            const index = outcome.index;
+            if (index === null || !Number.isInteger(index) || index < 0 || index >= dialog.options.length)
+                return "not an answer";
+            // Right before the key: the same question on screen on two looks a settle apart, or nothing
+            // is sent.
+            const first = sameDialog(await capture(), dialog);
+            if (first)
+                await deps.sleep(exports.SETTLE_MS);
+            if (!first || !sameDialog(await capture(), dialog)) {
+                await deps.notice(`${session}: your answer was not sent. The question was already answered in the terminal.`);
+                return "already answered";
+            }
+            const key = String(index + 1);
+            const pressed = await deps.press(key);
+            return pressed.ok ? `sent ${key}` : `refused: ${pressed.reason}`;
+        }
+        if (outcome.kind !== "deadline")
+            return outcome.kind === "failed" ? `failed: ${outcome.reason}` : outcome.kind;
+        // Nobody tapped yet. Answered at the keyboard meanwhile? Then the card goes.
+        if (!sameDialog(await capture(), dialog)) {
+            await deps.withdraw(outcome.requestId);
+            return "answered in the terminal";
+        }
+        if (deps.now() >= until) {
+            await deps.withdraw(outcome.requestId);
+            return "no answer";
+        }
+        await deps.sleep(GAP_MS);
+        outcome = await deps.poll(outcome.requestId, Math.min(until, deps.now() + WINDOW_MS));
+    }
+}
+function tmux(handle, args) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)("tmux", ["-S", handle.socket, ...args], { timeout: 5_000, encoding: "utf8" }, (err, out) => (err ? reject(err) : resolve(String(out))));
+    });
+}
+/** The real dependencies, for a tmux pane. */
+function paneAnswerDeps(device, handle) {
+    const log = (line) => process.stderr.write(`${line}\n`);
+    const waitDeps = { now: Date.now, sleep: (ms) => new Promise((r) => setTimeout(r, ms)), log };
+    return {
+        capture: () => tmux(handle, ["capture-pane", "-p", "-t", handle.pane]),
+        press: async (key) => {
+            if (!/^[1-9]$/.test(key))
+                return { ok: false, reason: `"${key}" is not a dialog answer` };
+            const check = (0, terminal_pane_1.verifyPane)(handle, "claude");
+            if (!check.ok)
+                return check;
+            try {
+                // `-l`: the digit as a character, never read as a key name.
+                await tmux(handle, ["send-keys", "-t", handle.pane, "-l", "--", key]);
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, reason: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        ask: (q, deadline) => (0, approval_wait_1.askOwnerAndWait)(device, q, deadline, waitDeps, "baychat notify-answer"),
+        poll: (id, deadline) => (0, approval_wait_1.waitOnOwnerQuestion)(device, id, deadline, waitDeps, "baychat notify-answer"),
+        withdraw: (id) => (0, approval_wait_1.withdrawOwnerQuestion)(device, id, log),
+        notice: async (text) => {
+            try {
+                await (0, api_1.apiRequest)(device, "POST", "/api/device-api/notify", { text });
+            }
+            catch {
+                // The answer was not sent either way; the note is a courtesy.
+            }
+        },
+        now: Date.now,
+        sleep: waitDeps.sleep,
+    };
+}
+/**
+ * `baychat notify-answer <session> <base64 JSON dialog>` — started detached by notify-hook inside
+ * the session's own environment (so `$TMUX_PANE` is the session's pane). Exits 0 always.
+ */
+async function cmdNotifyAnswer(argv = []) {
+    try {
+        const [session, encoded] = argv;
+        const dialog = JSON.parse(Buffer.from(encoded ?? "", "base64").toString("utf8"));
+        const handle = (0, terminal_pane_1.detectPane)();
+        const device = (0, config_1.loadDeviceCredentials)();
+        if (!session || !device || handle?.kind !== "tmux" || !dialog?.question || !Array.isArray(dialog.options))
+            return 0;
+        const outcome = await answerFromPhone({ session, dialog }, paneAnswerDeps(device, handle));
+        process.stderr.write(`baychat notify-answer: ${outcome}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`baychat notify-answer: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+    return 0;
+}