baychat 0.36.0 → 0.38.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "baychat",
-  "version": "0.36.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,19 +33,21 @@ 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;
 exports.composeQuestion = composeQuestion;
 exports.decideApproval = decideApproval;
 exports.sessionFromClaude = sessionFromClaude;
+exports.linkFromClaude = linkFromClaude;
 exports.procStatFields = procStatFields;
 exports.procStartTicks = procStartTicks;
 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.
@@ -88,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.
@@ -103,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: {
@@ -165,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.
  *
@@ -196,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 "";
         }
@@ -298,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) {
@@ -350,6 +388,10 @@ exports.MAX_CLAUDE_HOPS = 4;
  * Claude Code's own dialog.
  */
 function sessionFromClaude(deps = {}) {
+    return linkFromClaude(deps)?.session;
+}
+/** The channel's record for the Claude Code this hook runs under (claude-link.ts). Never throws. */
+function linkFromClaude(deps = {}) {
     const parentOf = deps.parentOf ?? psParentOf;
     const isAlive = deps.isAlive ?? claude_link_1.pidAlive;
     const readLink = deps.readLink ?? ((pid) => (0, claude_link_1.readClaudeLink)(pid));
@@ -366,7 +408,7 @@ function sessionFromClaude(deps = {}) {
                 const written = Date.parse(link.writtenAt);
                 const stale = age !== undefined && Number.isFinite(written) && written < now() - age - 5_000;
                 if (!stale)
-                    return link.session;
+                    return link;
             }
             pid = parentOf(pid);
         }
@@ -443,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);
@@ -460,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/channel/channel-check.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEED_RETRYING_HINT = exports.FEED_DOWN_HINT = void 0;
+exports.channelCheckLine = channelCheckLine;
+exports.cmdChannelCheck = cmdChannelCheck;
+/**
+ * `baychat channel-check` — the SessionStart hook (matcher `compact`) that says when this session's
+ * BayChat feed is down after a compact (Chat_claude, 29 Oct: the feed died silently at a compact and
+ * 15 minutes of @mentions went unheard). A SessionStart hook's output reaches the model; a
+ * PostCompact one's does not, and `context-hook` runs async and prints nothing on purpose.
+ *
+ * Only for a Claude Code started with the BayChat channel (detect.ts). Its channel server records
+ * the feed's health in `claude-sessions/<pid>.json` (claude-link.ts): no record, or one that says
+ * `retrying`, prints one line telling the session to call `listen`. NEVER FAILS OR BLOCKS: any
+ * error reading either is treated as "down" for a channel session and prints the hint; exit is 0.
+ */
+const approve_hook_1 = require("../approve-hook");
+const detect_1 = require("./detect");
+exports.FEED_DOWN_HINT = "BayChat feed down: call the BayChat channel's listen tool with your session name, then get_messages to catch up.";
+exports.FEED_RETRYING_HINT = "BayChat feed down (retrying in the background): call the BayChat channel's listen tool with your session name, then get_messages to catch up.";
+/** The line to print, or undefined when there is nothing to say. Never throws. */
+function channelCheckLine(deps = {}) {
+    let active = false;
+    try {
+        active = (deps.detect ?? (() => (0, detect_1.detectChannel)()))().active;
+    }
+    catch {
+        return undefined;
+    }
+    if (!active)
+        return undefined;
+    let link;
+    try {
+        link = (deps.link ?? approve_hook_1.linkFromClaude)();
+    }
+    catch {
+        return exports.FEED_DOWN_HINT;
+    }
+    if (!link)
+        return exports.FEED_DOWN_HINT;
+    return link.feed === "retrying" ? exports.FEED_RETRYING_HINT : undefined;
+}
+async function cmdChannelCheck(deps = {}) {
+    try {
+        const line = channelCheckLine(deps);
+        if (line)
+            (deps.out ?? ((l) => console.log(l)))(line);
+    }
+    catch {
+        // Nothing: a hook that fails must never stand in the way of the session.
+    }
+    return 0;
+}

package/dist/channel/claude-link.js

@@ -69,7 +69,11 @@ function writeClaudeLink(pid, session, opts = {}) {
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     sweepDeadLinks(dir, opts.isAlive ?? pidAlive);
     const file = claudeLinkPath(pid, dir);
-    const record = { session, writtenAt: (opts.now ?? (() => new Date()))().toISOString() };
+    const record = {
+        session,
+        writtenAt: (opts.now ?? (() => new Date()))().toISOString(),
+        ...(opts.feed ? { feed: opts.feed } : {}),
+    };
     // Write-then-rename, so the hook never reads half a file.
     const tmp = `${file}.${process.pid}.tmp`;
     fs.writeFileSync(tmp, `${JSON.stringify(record)}\n`, { mode: 0o600 });
@@ -89,7 +93,8 @@ function readClaudeLink(pid, dir = claudeSessionsDir()) {
         const raw = JSON.parse(fs.readFileSync(claudeLinkPath(pid, dir), "utf8"));
         if (typeof raw.session !== "string" || !raw.session.trim() || raw.session.length > 60 || typeof raw.writtenAt !== "string")
             return undefined;
-        return { session: raw.session, writtenAt: raw.writtenAt };
+        const feed = raw.feed === "retrying" ? "retrying" : raw.feed === "open" ? "open" : undefined;
+        return { session: raw.session, writtenAt: raw.writtenAt, ...(feed ? { feed } : {}) };
     }
     catch {
         return undefined;
@@ -124,9 +129,9 @@ function pidAlive(pid) {
 /** The real link: keyed by this process's parent — the Claude Code that started the channel server. */
 function realClaudeLink(log, pid = process.ppid) {
     return {
-        write: (session) => {
+        write: (session, feed) => {
             try {
-                writeClaudeLink(pid, session);
+                writeClaudeLink(pid, session, feed ? { feed } : {});
             }
             catch (err) {
                 // Approvals then stay in the terminal for this session: the hook finds no link and says nothing.

package/dist/channel/feed.js

@@ -29,6 +29,18 @@ class ChannelFeed {
     retryTimer;
     watchdogTimer;
     lastTick = 0;
+    /**
+     * A re-listen is starting a new feed for this session (server.ts). The server closes this one
+     * with 4000 once the new one is seated: taken quietly, because the new feed is this session's.
+     */
+    replacing = false;
+    /** The server closed this feed during a replacement that then failed: reconnect on cancel. */
+    closedForReplacement = false;
+    /**
+     * Down with nothing else running (a first start that failed): retried for as long as the
+     * channel lives, never given up on, and a `reset` once it is back — so the session catches up.
+     */
+    down = false;
     now;
     setTimer;
     clearTimer;
@@ -60,13 +72,13 @@ class ChannelFeed {
         const minted = await this.deps.mint(undefined);
         if (!minted.ok) {
             this.state = "stopped";
-            return { ok: false, detail: minted.detail };
+            return { ok: false, detail: minted.detail, fatal: minted.fatal };
         }
         const ready = await new Promise((resolve) => {
             const timer = this.setTimer(() => {
                 this.teardown();
                 this.state = "stopped";
-                resolve({ ok: false, detail: "The BayChat feed did not answer within 10 seconds." });
+                resolve({ ok: false, detail: "The BayChat feed did not answer within 10 seconds.", fatal: false });
             }, this.deps.readyTimeoutMs ?? READY_TIMEOUT_MS);
             this.open(minted.ticket, {
                 onReady: () => {
@@ -77,14 +89,41 @@ class ChannelFeed {
                     this.clearTimer(timer);
                     this.teardown();
                     this.state = "stopped";
-                    resolve({ ok: false, detail });
+                    resolve({ ok: false, detail, fatal: false });
                 },
             });
         });
-        if (ready.ok)
+        if (ready.ok) {
             this.armWatchdog();
+            this.deps.onHealth?.(true);
+        }
         return ready;
     }
+    /** A new feed for this session is starting: a 4000 from the server is that, not an ending. */
+    expectReplacement() {
+        this.replacing = true;
+    }
+    /** The new feed did not start: this one carries on, and reconnects if the server closed it. */
+    cancelReplacement() {
+        this.replacing = false;
+        if (this.closedForReplacement && this.state !== "stopped") {
+            this.closedForReplacement = false;
+            this.scheduleReconnect("was closed for a re-listen that did not start");
+        }
+    }
+    /**
+     * A first start that failed for now, with no other feed for this session: keep trying in the
+     * background (backoff up to a minute, never giving up), say so now, and say `reset` once back.
+     */
+    retryInBackground(detail) {
+        this.down = true;
+        this.state = "retrying";
+        this.attempt = 0;
+        this.deps.onHealth?.(false);
+        void this.deps.push(`BayChat's feed for session "${this.deps.session}" is down (${detail}); retrying in the background. ` +
+            `Until it is back this session does not hear the Bay. A reset event follows when it is back; then catch up with get_messages.`, this.meta({ event: "stopped" }));
+        this.scheduleReconnect(`did not start (${detail})`);
+    }
     /** Stop for good: no reconnect, no watchdog. Used on replace and on process exit. */
     stop() {
         const was = this.state;
@@ -174,6 +213,13 @@ class ChannelFeed {
                         this.state = "open";
                         this.attempt = 0;
                         this.log(`feed for ${this.deps.session} ready`);
+                        if (this.down) {
+                            this.down = false;
+                            this.armWatchdog();
+                            void this.pushReset();
+                        }
+                        if (!first)
+                            this.deps.onHealth?.(true);
                         first?.onReady();
                         return;
                     }
@@ -194,6 +240,12 @@ class ChannelFeed {
                         first.onFailBeforeReady(`The BayChat feed closed before it was ready (${code}${reason ? `: ${reason}` : ""}).`);
                         return;
                     }
+                    if (code === exports.CLOSE_STOPPED && this.replacing) {
+                        // The re-listen's new feed was seated: it is this session's now (server.ts stops this one).
+                        this.log(`feed for ${this.deps.session} closed for its replacement`);
+                        this.closedForReplacement = true;
+                        return;
+                    }
                     if (code === exports.CLOSE_STOPPED) {
                         // Stopped or replaced on purpose — by stop_listening, end_session, or a newer
                         // listener for this session. Reconnecting would fight whichever replaced it.
@@ -217,7 +269,9 @@ class ChannelFeed {
     scheduleReconnect(why) {
         if (this.state === "stopped")
             return;
-        if (this.attempt >= exports.MAX_FAILED_RECONNECTS) {
+        if (this.state === "open")
+            this.deps.onHealth?.(false);
+        if (!this.down && this.attempt >= exports.MAX_FAILED_RECONNECTS) {
             this.log(`feed for ${this.deps.session} gave up after ${this.attempt} failed reconnects (${why})`);
             this.stop();
             void this.pushStopped(`${this.attempt} reconnects in a row failed (last: ${why})`);

package/dist/channel/server.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChannelService = exports.nodeFeedConnect = exports.CHANNEL_INSTRUCTIONS = void 0;
+exports.ChannelService = exports.nodeFeedConnect = exports.LISTEN_RETRY_MS = exports.CHANNEL_INSTRUCTIONS = void 0;
 exports.realCommandLink = realCommandLink;
 exports.relaySocketFor = relaySocketFor;
 exports.realLogin = realLogin;
@@ -102,6 +102,12 @@ const LISTEN_TOOL = {
         required: ["session"],
     },
 };
+/**
+ * Waits between `listen`'s attempts at a feed that failed for now (a network error, a 5xx): three
+ * attempts over about ten seconds before it answers (Chat_claude, 29 Oct: one "fetch failed" right
+ * after a compact was the whole answer, and the session heard nothing for 15 minutes).
+ */
+exports.LISTEN_RETRY_MS = [2_000, 6_000];
 /**
  * The real command link: the relay socket of the session's Bay, and the pane and Claude Code
  * process THIS process inherited — Claude Code starts the channel server, so its `$TMUX` and its
@@ -297,24 +303,36 @@ class ChannelService {
             return toolResult("failed", `Failed: ${detail} Use listen_messages and a native Monitor instead.`, { session, stage: "login", detail });
         }
         const key = `${bayName ?? ""}\u0000${session}`;
-        this.feeds.get(key)?.stop();
+        // A RE-LISTEN KEEPS WHAT RUNS until its new feed is seated (Chat_claude, 29 Oct): stopping the
+        // old feed first meant one failed mint cost the session a working feed. The old feed's relay
+        // link is reused too — a new registration would replace it at the relay, failed start or not.
+        const previous = this.feeds.get(key);
+        const live = previous && previous.currentState !== "stopped" ? previous : undefined;
+        const reused = live ? this.links.get(key) : undefined;
         // COMMANDS FIRST, so the first ticket already says whether this computer's relay runs them.
         // When that changes (the relay starts, stops or restarts), the feed is reopened so the
         // server's view follows (realtime/remote-listeners.ts). Never a reason to fail `listen`.
-        let feed;
-        const link = this.openCommandLink(key, session, bay, bayName, (registered) => feed?.reopen(registered ? "now has this computer's relay running its commands" : "lost this computer's relay"));
-        if (link)
+        const link = reused ??
+            this.openCommandLink(key, session, bay, bayName, (registered) => this.feeds.get(key)?.reopen(registered ? "now has this computer's relay running its commands" : "lost this computer's relay"));
+        if (link && !reused)
             await link.start();
-        feed = new feed_1.ChannelFeed({
+        const feed = new feed_1.ChannelFeed({
             session,
             ...(bayName ? { bayName } : {}),
             mint: (cursor) => mintTicket(this.deps, { bay, session, cursor, ...(link?.registered ? { commands: "relay" } : {}) }),
             onStop: () => {
+                // Replaced by a re-listen: the link and the hook's record are the new feed's now.
+                if (this.feeds.get(key) !== feed)
+                    return;
                 this.closeCommandLink(key, link);
                 // A stopped feed: the hook must not keep sending cards in a name that may be gone.
                 if (bay === undefined)
                     this.deps.claudeLink?.remove(session);
             },
+            onHealth: (up) => {
+                if (bay === undefined && this.feeds.get(key) === feed)
+                    this.deps.claudeLink?.write(session, up ? "open" : "retrying");
+            },
             connect: this.deps.connect,
             status: async () => {
                 try {
@@ -332,23 +350,40 @@ class ChannelService {
             log: this.deps.log,
             ...this.deps.feedOverrides,
         });
-        this.feeds.set(key, feed);
-        const started = await feed.start();
+        live?.expectReplacement();
+        const started = await this.startWithRetries(feed, session);
         if (!started.ok) {
-            this.feeds.delete(key);
-            this.closeCommandLink(key, link);
+            this.deps.log(`listen ${session}: the feed did not start: ${started.detail}`);
+            if (live) {
+                // The feed that was running carries on; only the new one is given up.
+                live.cancelReplacement();
+                return toolResult("active", `Active: a new feed could not start (${started.detail}), so the feed already running for session "${session}" ` +
+                    `keeps going. Messages still arrive as <channel> events; do NOT open a Monitor or call listen_messages.`, { session, ...(bayName ? { bay: bayName } : {}), kept: true, detail: started.detail });
+            }
+            if (!started.fatal) {
+                // Nothing else runs for this session: retry in the background rather than go quiet.
+                this.feeds.set(key, feed);
+                this.last = { key, session, bay };
+                feed.retryInBackground(started.detail);
+                return toolResult("retrying", `Retrying: the BayChat feed for session "${session}" could not start (${started.detail}). It keeps retrying in the ` +
+                    `background, and a <channel event="reset"> says when it is back — then catch up with get_messages. Until then, ` +
+                    `read get_messages when you expect a message. Do NOT open a Monitor: it would compete with this feed.`, { session, ...(bayName ? { bay: bayName } : {}), stage: "feed", detail: started.detail });
+            }
+            if (!reused)
+                this.closeCommandLink(key, link);
             if (this.last?.key === key)
                 this.last = undefined;
-            this.deps.log(`listen ${session}: the feed did not start: ${started.detail}`);
             return toolResult("failed", `Failed: ${started.detail} Use listen_messages and a native Monitor instead.`, { session, stage: "feed", detail: started.detail });
         }
+        this.feeds.set(key, feed);
+        live?.stop();
         this.last = { key, session, bay };
         // Approvals for `baychat claude` / `baychat start` (approve-hook --session-from-claude): this
         // Claude Code is now this session. Only for the default Bay, the one the hook's device login
         // asks; a session on another Bay keeps its prompts in the terminal (and clears an older link,
         // so a card never goes out in a name this Claude Code has moved on from).
         if (bay === undefined)
-            this.deps.claudeLink?.write(session);
+            this.deps.claudeLink?.write(session, "open");
         else
             this.deps.claudeLink?.remove(undefined);
         return toolResult("active", `Active: session "${session}"${bayName ? ` (${bayName})` : ""} now hears the Bay through the channel. New messages ` +
@@ -357,6 +392,19 @@ class ChannelService {
             `to catch up on anything from before listening.` +
             (link ? ` ${link.describeReach()}` : ""), { session, ...(bayName ? { bay: bayName } : {}), how: evidence.how, commands: link?.state.kind ?? "off" });
     }
+    /** `feed.start()`, again after a failure for now; a final one (a gone session) answers at once. */
+    async startWithRetries(feed, session) {
+        const sleep = this.deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        let started = await feed.start();
+        for (const wait of exports.LISTEN_RETRY_MS) {
+            if (started.ok || started.fatal)
+                return started;
+            this.deps.log(`listen ${session}: ${started.detail}; trying again in ${wait / 1000}s`);
+            await sleep(wait);
+            started = await feed.start();
+        }
+        return started;
+    }
     /**
      * Register this session's commands with the relay (relay-link.ts). A fresh start's note
      * request comes back over it and is handed to the session as an event — the relay drops a

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/launch/command.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trustByHand = exports.CODEX_UNATTENDED_NOTICE = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
+exports.trustByHand = exports.CODEX_UNATTENDED_NOTICE = exports.AGENT_STARTS_NOTICE = exports.APPROVALS_NOTICE = exports.LAUNCH_USAGE = void 0;
 exports.cmdLaunch = cmdLaunch;
 const path = __importStar(require("path"));
 const args_1 = require("../args");
@@ -41,13 +41,18 @@ const multiplexer_launch_1 = require("../multiplexer-launch");
 const policy_1 = require("../relay/acp/policy");
 const claude_trust_1 = require("./claude-trust");
 const policy_2 = require("./policy");
-exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>] [--unattended]
+exports.LAUNCH_USAGE = `Usage: baychat launch add <folder> [--label <label>] [--runtime claude,codex] [--max <n>] [--unattended] [--agent-starts]
                                   Let BayChat start sessions in <folder> from the app
                                   (--unattended: also let it start Codex there, which then never asks)
+                                  (--agent-starts: agents you allowed "Always" may start sessions there without asking you each time)
        baychat launch list         The folders BayChat may start sessions in
        baychat launch remove <id>  Stop offering one of them`;
 /** Printed by every `add`: the one thing a person must know before saying yes. */
 exports.APPROVALS_NOTICE = "Claude Code sessions started here from BayChat ask for approvals in BayChat.";
+/** Printed by an `add … --agent-starts`: what the second key opens, and what it never does. */
+exports.AGENT_STARTS_NOTICE = "Agents you allowed with \"Always for this agent here\" on their card may start sessions here without asking you each time — " +
+    "only for this folder, computer and runtime, for 30 days, and only with no task or one of your own messages as the task: a task an agent or anyone else writes still asks. " +
+    "Those sessions ask for approvals in BayChat like any other; they never start Codex unattended. Revoke an agent in Settings → Devices.";
 /** Printed when Codex is offered: what it may do without asking, and what it asks on the phone. */
 exports.CODEX_UNATTENDED_NOTICE = "Codex started here from BayChat is run by the relay (Codex 0.160 or newer): it can change files in this folder without asking, with no network, " +
     "and asks for approval in BayChat — on the session owner's phone — before anything more (a command outside its sandbox, network access, files elsewhere). " +
@@ -89,6 +94,7 @@ async function addSpot(args, deps) {
     const runtimeList = (0, args_1.flag)(args, "--runtime");
     const maxRaw = (0, args_1.flag)(args, "--max");
     const unattended = args.includes("--unattended");
+    const agentStarts = args.includes("--agent-starts");
     const valued = new Set([label, runtimeList, maxRaw].filter((v) => v !== undefined));
     const folderArg = args.find((a) => !a.startsWith("--") && !valued.has(a));
     if (unattended && !(runtimeList ?? "").split(",").map((r) => r.trim()).includes("codex")) {
@@ -127,11 +133,14 @@ async function addSpot(args, deps) {
         runtimes: [...new Set(requested)],
         maxSessions,
         ...(unattended ? { unattendedCodex: true } : {}),
+        ...(agentStarts ? { agentStarts: true } : {}),
     };
     (0, policy_2.saveLaunchPolicy)((0, policy_2.upsertSpot)(policy, spot), deps.policyFile);
     deps.print(`${existing ? "Updated" : "Added"} "${spot.label}" (${spot.id}): ${spot.path}`);
     deps.print(`  Agents: ${spot.runtimes.join(", ")} · at most ${spot.maxSessions} at once`);
     deps.print(`  ${exports.APPROVALS_NOTICE}`);
+    if (spot.agentStarts)
+        deps.print(`  ${exports.AGENT_STARTS_NOTICE}`);
     if (spot.runtimes.includes("codex")) {
         deps.print(spot.unattendedCodex
             ? `  ${exports.CODEX_UNATTENDED_NOTICE}`
@@ -176,8 +185,10 @@ function listSpots(deps) {
         deps.print("BayChat may not start sessions on this computer. Add a folder with `baychat launch add <folder>`.");
         return 0;
     }
-    for (const s of policy.spots)
-        deps.print(`${s.id}  "${s.label}"  ${s.path}  [${s.runtimes.join(", ")}] max ${s.maxSessions}`);
+    for (const s of policy.spots) {
+        const flags = [s.unattendedCodex ? "unattended Codex" : "", s.agentStarts ? "agent starts" : ""].filter(Boolean);
+        deps.print(`${s.id}  "${s.label}"  ${s.path}  [${s.runtimes.join(", ")}] max ${s.maxSessions}${flags.length ? `  (${flags.join(", ")})` : ""}`);
+    }
     return 0;
 }
 function removeSpotById(args, deps) {