baychat 0.37.0 → 0.38.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.37.0",
+  "version": "0.38.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/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

@@ -174,6 +174,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 +231,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 +241,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,6 +7,8 @@ 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 update_command_1 = require("./update-command");
@@ -338,6 +340,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;
+}

package/dist/notify-hook.js

@@ -0,0 +1,227 @@
+"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.NOTICE_MAX = exports.CARD_PENDING_MAX_MS = exports.NOTIFY_MIN_GAP_MS = exports.NOTIFY_TYPES = void 0;
+exports.lastToolUse = lastToolUse;
+exports.decideNotify = decideNotify;
+exports.cmdNotifyHook = cmdNotifyHook;
+// `baychat notify-hook` — the stuck-question safety net (29 Oct).
+//
+// WHY THIS EXISTS. Branding's Claude Code sat on a terminal dialog ("Jelly Fish" was made by
+// someone else. Let Claude read it?) and nothing reached Karmen's phone: its approve-hook could not
+// name its session (the claude-sessions link was gone), so it left the prompt to the terminal in
+// silence. Messages piled up unread, because Claude Code reads nothing while a question is open.
+//
+// WHAT CLAUDE CODE GIVES US: the `Notification` event, in every session, joined or not, about 6 s
+// after a permission dialog or an MCP form appears (`permission_prompt`, `elicitation_dialog`,
+// `elicitation_url_dialog`; reproduced 29 Oct). Watch-only: its output answers nothing, and its
+// `message` does not hold the question ("Claude needs your permission"), so the question is read
+// from the model's last tool call in the transcript. `idle_prompt` is not taken: it fires a minute
+// after every normal answer.
+//
+// WHAT IT DOES: one line to the owner's phone — "<session> (<folder>) is waiting on a question in its
+// terminal: <what>" — through `POST /api/device-api/notify` (the owner's private chat with BayBrain,
+// a system line and a push). Once per prompt, at most one a minute per session, and nothing while
+// approve-hook's own card for this session is on the phone (notify-state.ts). Prints nothing and
+// exits 0 on every path: a Notification hook can block nothing, and must never stand in the way.
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const api_1 = require("./api");
+const approve_hook_1 = require("./approve-hook");
+const config_1 = require("./config");
+const hook_stdin_1 = require("./hook-stdin");
+const notify_answer_1 = require("./notify-answer");
+const notify_state_1 = require("./notify-state");
+const terminal_pane_1 = require("./relay/terminal-pane");
+/** The notifications that mean "a question is open in the terminal". */
+exports.NOTIFY_TYPES = ["permission_prompt", "elicitation_dialog", "elicitation_url_dialog"];
+/** At most one notice a minute per Claude Code session. */
+exports.NOTIFY_MIN_GAP_MS = 60_000;
+/** A card marker older than this is a hook that died mid-wait, not a card on the phone. */
+exports.CARD_PENDING_MAX_MS = 60 * 60_000;
+/** The server's cap (terminal-notice.service.ts). */
+exports.NOTICE_MAX = 300;
+/** How much of the transcript's end is read for the last tool call. */
+const TAIL_BYTES = 256 * 1024;
+/** The model's last tool call in transcript JSONL text, or undefined. */
+function lastToolUse(text) {
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const line = lines[i];
+        if (!line.includes('"tool_use"'))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue; // the cut-off first line of a tail, or a line being written
+        }
+        if (entry.type !== "assistant" || !Array.isArray(entry.message?.content))
+            continue;
+        const blocks = entry.message.content;
+        for (let j = blocks.length - 1; j >= 0; j--) {
+            const b = blocks[j];
+            if (b?.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string")
+                return { id: b.id, name: b.name, input: b.input };
+        }
+    }
+    return undefined;
+}
+function readTail(file) {
+    let fd;
+    try {
+        fd = fs.openSync(file, "r");
+        const size = fs.fstatSync(fd).size;
+        const length = Math.min(size, TAIL_BYTES);
+        const buf = Buffer.alloc(length);
+        fs.readSync(fd, buf, 0, length, size - length);
+        return buf.toString("utf8");
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+const str = (v) => (typeof v === "string" ? v : "");
+/** `/home/k/projects/branding` → `~/projects/branding`. */
+function shortPath(cwd) {
+    const home = os.homedir();
+    return cwd && home && (cwd === home || cwd.startsWith(`${home}/`)) ? `~${cwd.slice(home.length)}` : cwd;
+}
+function clip(text, max) {
+    return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
+}
+async function postNotice(device, text) {
+    await (0, api_1.apiRequest)(device, "POST", "/api/device-api/notify", { text });
+}
+/** This process's own tmux pane (the hook runs inside the session), as text; undefined elsewhere. */
+function readOwnPane() {
+    const handle = (0, terminal_pane_1.detectPane)();
+    if (handle?.kind !== "tmux")
+        return Promise.resolve(undefined);
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)("tmux", ["-S", handle.socket, "capture-pane", "-p", "-t", handle.pane], { timeout: 5_000, encoding: "utf8" }, (err, out) => resolve(err ? undefined : String(out)));
+    });
+}
+/** `baychat notify-answer <session> <dialog>`, detached, in this session's environment (its pane). */
+function startAnswerProcess(session, dialog) {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        const encoded = Buffer.from(JSON.stringify(dialog), "utf8").toString("base64");
+        (0, child_process_1.spawn)(process.execPath, [entry, "notify-answer", session, encoded], { detached: true, stdio: "ignore", env: process.env }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** One hook run. NEVER THROWS: every failure is a skip with its reason. */
+async function decideNotify(rawStdin, deps = {}) {
+    const now = deps.now ?? Date.now;
+    const opts = { dir: deps.stateDir };
+    try {
+        let input;
+        try {
+            input = JSON.parse(rawStdin);
+        }
+        catch {
+            return { skipped: "not a question" };
+        }
+        const type = str(input.notification_type);
+        if (input.hook_event_name !== "Notification" || !exports.NOTIFY_TYPES.includes(type))
+            return { skipped: "not a question" };
+        const sessionId = str(input.session_id);
+        const card = (0, notify_state_1.cardPendingSince)(sessionId, opts);
+        if (card !== undefined && now() - card < exports.CARD_PENDING_MAX_MS)
+            return { skipped: "a card is already on the phone" };
+        // What is being asked: the model's last tool call for a permission dialog, else Claude Code's own words.
+        const tool = type === "permission_prompt" ? lastToolUse(readTail(str(input.transcript_path)) ?? "") : undefined;
+        const what = tool ? (0, approve_hook_1.describeToolRequest)(tool.name, tool.input) : str(input.message) || "a question";
+        const key = tool ? `tool:${tool.id}` : `${type}:${str(input.message)}`;
+        const last = (0, notify_state_1.readLastNotice)(sessionId, opts);
+        if (last?.lastKey === key)
+            return { skipped: "already sent for this prompt" };
+        if (last && now() - last.lastAt < exports.NOTIFY_MIN_GAP_MS)
+            return { skipped: "one a minute per session" };
+        const device = (deps.loadDevice ?? config_1.loadDeviceCredentials)();
+        if (!device)
+            return { skipped: "not logged in" };
+        const session = (deps.link ?? approve_hook_1.linkFromClaude)()?.session;
+        // A session BayChat knows, in a tmux pane showing a numbered dialog: a card the owner can
+        // ANSWER, by a detached `notify-answer` that presses the chosen number (notify-answer.ts).
+        if (session) {
+            const screen = await (deps.readScreen ?? readOwnPane)();
+            const dialog = screen ? (0, notify_answer_1.readDialog)(screen) : undefined;
+            if (dialog && (deps.startAnswer ?? startAnswerProcess)(session, dialog)) {
+                (0, notify_state_1.writeLastNotice)(sessionId, { lastAt: now(), lastKey: key }, opts);
+                return { sent: true, answerable: true };
+            }
+        }
+        const who = session || "A Claude Code session";
+        const where = shortPath(str(input.cwd));
+        const head = `${who}${where ? ` (${where})` : ""} is waiting on a question in its terminal: `;
+        const text = clip(`${head}${what.replace(/\s+/g, " ").trim()}`, exports.NOTICE_MAX);
+        await (deps.post ?? postNotice)(device, text);
+        (0, notify_state_1.writeLastNotice)(sessionId, { lastAt: now(), lastKey: key }, opts);
+        return { sent: true };
+    }
+    catch (err) {
+        return { skipped: err instanceof Error ? err.message : String(err) };
+    }
+}
+/**
+ * `baychat notify-hook [--dry-run]` — always exits 0 and prints nothing; why it skipped goes to
+ * stderr. `--dry-run` writes the line it would send to stderr instead of sending it (and still
+ * needs a login, so it shows the real path up to the request).
+ */
+async function cmdNotifyHook(argv = [], stdin = process.stdin) {
+    try {
+        const dryRun = argv.includes("--dry-run");
+        const outcome = await decideNotify(await (0, hook_stdin_1.readStdin)(stdin), dryRun ? { post: async (_d, text) => void process.stderr.write(`baychat notify-hook (dry run): ${text}\n`) } : {});
+        if ("skipped" in outcome && outcome.skipped !== "not a question")
+            process.stderr.write(`baychat notify-hook: ${outcome.skipped}\n`);
+    }
+    catch {
+        // Nothing: a Notification hook must never stand in the way of the session.
+    }
+    return 0;
+}

package/dist/notify-state.js

@@ -0,0 +1,136 @@
+"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.notifyStateDir = void 0;
+exports.stateKey = stateKey;
+exports.markCardPending = markCardPending;
+exports.clearCardPending = clearCardPending;
+exports.cardPendingSince = cardPendingSince;
+exports.readLastNotice = readLastNotice;
+exports.writeLastNotice = writeLastNotice;
+/**
+ * What notify-hook remembers per Claude Code session, under `<config>/notify-state/`:
+ *
+ *  - `<session_id>.json` — the last notice sent: `{ lastAt, lastKey }`, for "once per prompt, at
+ *    most once a minute" (notify-hook.ts).
+ *  - `<session_id>.card` — approve-hook has a card on the owner's phone for this session right now.
+ *    Written when the card goes out and removed when the hook is done, so the same prompt never
+ *    reaches the phone twice (a card AND a "waiting" line). Its age bounds it: a hook killed
+ *    mid-wait leaves a file that stops counting after an hour.
+ *
+ * Small files, private to the user, never read by anything else. Every function swallows its own
+ * errors: a hook's bookkeeping must never stand in the way of the session.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const notifyStateDir = () => path.join((0, config_1.configDir)(), "notify-state");
+exports.notifyStateDir = notifyStateDir;
+/** A Claude Code session id as a file name: its own characters only, or nothing. */
+function stateKey(sessionId) {
+    return /^[A-Za-z0-9_-]{1,128}$/.test(sessionId) ? sessionId : undefined;
+}
+function file(sessionId, ext, dir) {
+    const key = stateKey(sessionId);
+    if (!key)
+        return undefined;
+    try {
+        return path.join(dir ?? (0, exports.notifyStateDir)(), `${key}.${ext}`);
+    }
+    catch {
+        // No config directory to keep it in: no bookkeeping, never an error on approve-hook's path.
+        return undefined;
+    }
+}
+function markCardPending(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(f), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(f, String((opts.now ?? Date.now)()), { mode: 0o600 });
+    }
+    catch {
+        // Bookkeeping only.
+    }
+}
+function clearCardPending(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.rmSync(f, { force: true });
+    }
+    catch {
+        // Bookkeeping only.
+    }
+}
+/** When the pending card was marked, or undefined when there is none. */
+function cardPendingSince(sessionId, opts = {}) {
+    const f = file(sessionId, "card", opts.dir);
+    if (!f)
+        return undefined;
+    try {
+        const at = Number(fs.readFileSync(f, "utf8").trim());
+        return Number.isFinite(at) ? at : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readLastNotice(sessionId, opts = {}) {
+    const f = file(sessionId, "json", opts.dir);
+    if (!f)
+        return undefined;
+    try {
+        const v = JSON.parse(fs.readFileSync(f, "utf8"));
+        return typeof v.lastAt === "number" && typeof v.lastKey === "string" ? { lastAt: v.lastAt, lastKey: v.lastKey } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeLastNotice(sessionId, notice, opts = {}) {
+    const f = file(sessionId, "json", opts.dir);
+    if (!f)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(f), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(f, JSON.stringify(notice), { mode: 0o600 });
+    }
+    catch {
+        // Bookkeeping only: at worst the next prompt's notice is not rate-limited.
+    }
+}

package/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "BayChat's denied-command card for every session, also ones started by hand: an auto-mode denial becomes a card in the session's BayChat chat once it has joined (docs/features/DENIED_COMMAND_CARD.md). After a compact, a channel session is told when its BayChat feed is down (channel-check). No PostToolUse hook: it would start baychat on every tool call.",
+  "description": "BayChat's denied-command card for every session, also ones started by hand: an auto-mode denial becomes a card in the session's BayChat chat once it has joined (docs/features/DENIED_COMMAND_CARD.md). After a compact, a channel session is told when its BayChat feed is down (channel-check). A question left open in the terminal (a permission dialog, an MCP form) becomes one line on the owner's phone (notify-hook). No PostToolUse hook: it would start baychat on every tool call.",
   "hooks": {
     "PermissionDenied": [
       {
@@ -9,7 +9,7 @@
             "type": "command",
             "command": "baychat denied-hook --session-from-claude --plugin --timeout 3600",
             "timeout": 3900,
-            "statusMessage": "Blocked by auto mode \u2014 asking in BayChat\u2026"
+            "statusMessage": "Blocked by auto mode — asking in BayChat…"
           }
         ]
       }
@@ -25,6 +25,18 @@
           }
         ]
       }
+    ],
+    "Notification": [
+      {
+        "matcher": "permission_prompt|elicitation_dialog|elicitation_url_dialog",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "baychat notify-hook",
+            "timeout": 30
+          }
+        ]
+      }
     ]
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.37.0",
+  "version": "0.38.0",
   "description": "BayChat connector CLI — pair an agent session (Claude Code, Codex, Cursor) with BayChat, or have the relay run DeepSeek or the Cursor CLI for you",
   "bin": {
     "baychat": "dist/index.js"