baychat 0.29.9 → 0.31.0

package/dist/auto-update/updater.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoUpdater = exports.TICK_MS = exports.UPDATE_NOW_INDEX = exports.UPDATE_OPTIONS = void 0;
+const self_upgrade_1 = require("../self-upgrade");
+const policy_1 = require("./policy");
+const self_restart_1 = require("../relay/self-restart");
+exports.UPDATE_OPTIONS = ["Update now", "Later"];
+exports.UPDATE_NOW_INDEX = 0;
+/** How often the state is looked at. Cheap: one small file and the clock. */
+exports.TICK_MS = 60_000;
+class AutoUpdater {
+    deps;
+    startedAt;
+    /** Spreads this relay's checks; fixed for its lifetime so the schedule does not wander. */
+    spread;
+    timer;
+    running = false;
+    stopped = false;
+    lastCardPoll = 0;
+    constructor(deps) {
+        this.deps = deps;
+        this.startedAt = deps.now();
+        this.spread = deps.random();
+    }
+    /** Finish an update the previous relay installed, then look at the state once a minute. */
+    start() {
+        void this.runExclusive(() => this.finishPendingUpdate());
+        this.timer = setInterval(() => void this.tick(), exports.TICK_MS);
+        this.timer.unref();
+    }
+    stop() {
+        this.stopped = true;
+        clearInterval(this.timer);
+    }
+    status() {
+        const state = this.deps.loadState();
+        const { mode, reason } = this.mode();
+        return {
+            mode,
+            reason,
+            current: this.deps.current,
+            latest: state.latest,
+            lastCheckAt: state.lastCheckAt,
+            waitingFor: state.waitingFor,
+            cardVersion: state.card?.requestId ? state.card.version : undefined,
+            failure: state.failure?.reason,
+        };
+    }
+    /** One look at the state. Never throws; never runs twice at once. */
+    async tick() {
+        await this.runExclusive(async () => {
+            if (this.stopped)
+                return;
+            const state = this.deps.loadState();
+            const { mode, reason } = this.mode();
+            if (state.mode !== mode || state.modeReason !== reason || state.current !== this.deps.current) {
+                Object.assign(state, { mode, modeReason: reason, current: this.deps.current });
+                this.deps.saveState(state);
+            }
+            // New files are on disk under old code: restarting onto them comes before anything else,
+            // whatever the setting says now — running half old, half new is the one state to avoid.
+            if (state.finish)
+                return this.finishPendingUpdate();
+            if (mode === "off" || mode === "none")
+                return;
+            const now = this.deps.now();
+            if (now >= (0, policy_1.nextCheckAt)(state, this.startedAt, this.spread))
+                await this.check(state, mode);
+            if (mode !== "auto")
+                return;
+            if (state.card?.requestId && now - this.lastCardPoll >= policy_1.CARD_POLL_MS)
+                await this.pollCard(state);
+            if (state.target)
+                await this.installTarget(state);
+        });
+    }
+    mode() {
+        const off = (0, policy_1.autoUpdateOffReason)(this.deps.env, this.deps.setting());
+        if (off)
+            return { mode: "off", reason: off };
+        const { install, supervised, root } = this.deps.ability;
+        if (install.kind === "source")
+            return { mode: "none", reason: "running from a checkout" };
+        if (install.kind === "npx")
+            return { mode: "notify", reason: "for an npx copy (use `npx baychat@latest`)" };
+        if (install.kind === "local")
+            return { mode: "notify", reason: "for a project install (update it there with `npm i baychat@latest`)" };
+        if (root)
+            return { mode: "notify", reason: "as root (install with `baychat update`)" };
+        if (!(0, self_restart_1.selfUpdateAllowedOn)(this.deps.ability.platform))
+            return { mode: "notify", reason: "on Windows (install with `baychat update`)" };
+        if (!supervised)
+            return { mode: "notify", reason: "for a relay started by hand (install with `baychat update`)" };
+        return { mode: "auto" };
+    }
+    /** Ask npm, and decide. */
+    async check(state, mode) {
+        const looked = await this.deps.lookupLatest();
+        state.lastCheckAt = this.deps.now();
+        if (!looked.ok) {
+            // Offline, npm down: quiet. Tried again within the hour, then less often.
+            state.checkFailures = (state.checkFailures ?? 0) + 1;
+            state.lastCheckError = looked.reason;
+            this.deps.log(`auto-update: could not ask npm (${looked.reason})`);
+            return this.deps.saveState(state);
+        }
+        state.checkFailures = 0;
+        state.lastCheckError = undefined;
+        state.latest = looked.release.version;
+        const plan = (0, policy_1.planUpdate)(this.deps.current, looked.release);
+        if (plan.kind === "current") {
+            // Updated some other way (`baychat update`), or nothing new: nothing may stay on the phone.
+            await this.dropCard(state);
+            state.target = undefined;
+            return this.deps.saveState(state);
+        }
+        if (mode === "notify") {
+            this.notifyOnce(state, `available:${plan.version}`, this.availableLine(plan.version));
+            return this.deps.saveState(state);
+        }
+        if (plan.kind === "auto") {
+            if (state.target?.version !== plan.version)
+                state.target = { version: plan.version, via: "auto" };
+            return this.deps.saveState(state);
+        }
+        await this.askOwner(state, plan.version, plan.reason);
+        this.deps.saveState(state);
+    }
+    /** The card for a version that needs the person. At most one per version, never while one waits. */
+    async askOwner(state, version, reason) {
+        if (state.target?.version === version)
+            return; // already said "Update now"
+        const card = state.card;
+        if (card?.version === version && (card.requestId || (card.laterUntil ?? 0) > this.deps.now()))
+            return;
+        if (card && card.version !== version)
+            await this.dropCard(state); // a newer version supersedes it
+        this.notifyOnce(state, `ask:${version}`, `baychat ${version} needs you: ${reason}. Run \`baychat update\` when you are ready.`);
+        const asked = await this.deps.cards.ask(`New BayChat for your computer (${version}): ${reason}`);
+        if (!asked) {
+            this.deps.log(`auto-update: ${version} needs the owner, and no card could be put up yet`);
+            return;
+        }
+        state.card = { version, reason, askedAt: this.deps.now(), ...asked };
+        this.deps.log(`auto-update: asked the owner about ${version} (${reason})`);
+    }
+    async pollCard(state) {
+        this.lastCardPoll = this.deps.now();
+        const card = state.card;
+        const answer = await this.deps.cards.answer(card.requestId);
+        if (answer.kind === "waiting")
+            return;
+        if (answer.kind === "update") {
+            this.deps.log(`auto-update: the owner chose to update to ${card.version}`);
+            state.target = { version: card.version, via: "card", conversationId: card.conversationId, session: card.session };
+            state.card = undefined;
+        }
+        else {
+            // "Later", or the card is gone (withdrawn, deleted): ask again in a few days, not before.
+            state.card = { ...card, requestId: undefined, laterUntil: this.deps.now() + policy_1.ASK_AGAIN_MS };
+        }
+        this.deps.saveState(state);
+    }
+    /** Install the decided version in a quiet moment, then restart onto it in another. */
+    async installTarget(state) {
+        const target = state.target;
+        if ((0, self_upgrade_1.compareVersions)(this.deps.current, target.version) !== -1) {
+            state.target = undefined;
+            return this.deps.saveState(state);
+        }
+        if (this.deps.now() < (0, policy_1.installAllowedAt)(state.failure, target.version))
+            return;
+        const busy = this.deps.busyReason();
+        if (busy)
+            return this.wait(state, busy);
+        this.deps.log(`auto-update: installing baychat ${target.version} (from ${this.deps.current})`);
+        const installed = await this.deps.installVersion(target.version);
+        if (!installed.ok) {
+            const count = state.failure?.version === target.version ? state.failure.count + 1 : 1;
+            state.failure = { version: target.version, count, at: this.deps.now(), reason: installed.reason };
+            state.waitingFor = undefined;
+            this.deps.log(`auto-update: install of ${target.version} failed (${installed.reason}); ${this.deps.current} keeps running`);
+            this.notifyOnce(state, `failed:${target.version}`, `BayChat could not update itself to ${target.version}: ${installed.reason}`);
+            return this.deps.saveState(state);
+        }
+        // The new code is on disk. From here the NEW relay finishes, whoever restarts it.
+        state.finish = { from: this.deps.current, to: installed.to, via: target.via, conversationId: target.conversationId, session: target.session };
+        state.target = undefined;
+        state.failure = undefined;
+        state.waitingFor = undefined;
+        this.deps.saveState(state);
+        await this.restartWhenQuiet();
+    }
+    /** Restart now if nothing is going on, else on a later tick (the `finish` step marks it owed). */
+    async restartWhenQuiet() {
+        const state = this.deps.loadState();
+        if (!state.finish)
+            return;
+        const busy = this.deps.busyReason();
+        if (busy)
+            return this.wait(state, busy);
+        state.finish.restarts = (state.finish.restarts ?? 0) + 1;
+        state.waitingFor = undefined;
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: restarting onto baychat ${state.finish.to}`);
+        await this.deps.restart();
+    }
+    wait(state, busy) {
+        if (state.waitingFor === busy)
+            return;
+        state.waitingFor = busy;
+        this.deps.saveState(state);
+    }
+    /**
+     * Run at start. If the previous relay installed a version and this IS that version, finish it.
+     * If this is still the old code (its restart came up on the old files somehow), the install
+     * evidently did not land: forget it, and the next check decides again.
+     */
+    async finishPendingUpdate() {
+        const state = this.deps.loadState();
+        const finish = state.finish;
+        if (!finish)
+            return this.dropStaleCard(state);
+        if ((0, self_upgrade_1.compareVersions)(this.deps.current, finish.to) === -1) {
+            // Still the old code. Never restarted yet (the old relay died first): restart onto the new
+            // files. Restarted already and STILL old: the init system runs a different copy than the one
+            // updated. Give up on it rather than restart forever; the failure backs the next try off.
+            if (!finish.restarts)
+                return this.restartWhenQuiet();
+            const reason = `the relay restarted but still runs ${this.deps.current}`;
+            state.finish = undefined;
+            state.failure = { version: finish.to, count: 1, at: this.deps.now(), reason };
+            this.deps.log(`auto-update: ${reason}, not ${finish.to}`);
+            this.notifyOnce(state, `failed:${finish.to}`, `BayChat could not update itself to ${finish.to}: ${reason}. Run \`baychat update\`.`);
+            return this.deps.saveState(state);
+        }
+        state.finish = undefined;
+        state.lastUpdate = { from: finish.from, to: finish.to, at: this.deps.now() };
+        this.deps.saveState(state);
+        await this.refreshClientsQuietly();
+        this.notifyOnce(state, `updated:${finish.to}`, `BayChat updated itself to ${finish.to} (from ${finish.from}).`);
+        this.deps.saveState(state);
+        this.deps.log(`auto-update: now running baychat ${finish.to} (from ${finish.from})`);
+        await this.sayDone(finish);
+        await this.dropStaleCard(this.deps.loadState());
+    }
+    async refreshClientsQuietly() {
+        try {
+            await this.deps.refreshClients();
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not refresh client configs (${errText(err)})`);
+        }
+    }
+    /** The owner asked for this one: tell them, once, where they asked. A routine update stays quiet. */
+    async sayDone(finish) {
+        if (finish.via !== "card" || !finish.conversationId || !finish.session)
+            return;
+        try {
+            await this.deps.cards.say(finish.conversationId, finish.session, `Updated BayChat on this computer to ${finish.to}.`);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not say the update was done (${errText(err)})`);
+        }
+    }
+    /** A card about a version this relay already runs (updated by hand meanwhile) comes off the phone. */
+    async dropStaleCard(state) {
+        if (!state.card || (0, self_upgrade_1.compareVersions)(this.deps.current, state.card.version) === -1)
+            return;
+        await this.dropCard(state);
+        this.deps.saveState(state);
+    }
+    async dropCard(state) {
+        const requestId = state.card?.requestId;
+        state.card = undefined;
+        if (!requestId)
+            return;
+        try {
+            await this.deps.cards.withdraw(requestId);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not withdraw the update card (${errText(err)})`);
+        }
+    }
+    /** One line for the terminal, and never the same line twice. */
+    notifyOnce(state, key, text) {
+        if (state.noticeKey === key)
+            return;
+        state.noticeKey = key;
+        try {
+            this.deps.notify(text);
+        }
+        catch (err) {
+            this.deps.log(`auto-update: could not leave the terminal notice (${errText(err)})`);
+        }
+    }
+    availableLine(version) {
+        const { install } = this.deps.ability;
+        if (install.kind === "npx")
+            return `baychat ${version} is available. Use \`npx baychat@latest\`, or install it once with \`npm i -g baychat\` so it updates itself.`;
+        if (install.kind === "local")
+            return `baychat ${version} is available. Update it in ${install.packageRoot} with \`npm i baychat@latest\`.`;
+        return `baychat ${version} is available. Run \`baychat update\`.`;
+    }
+    async runExclusive(work) {
+        if (this.running)
+            return;
+        this.running = true;
+        try {
+            await work();
+        }
+        catch (err) {
+            // A bug in one look must not end the loop: the next tick starts from the state on disk.
+            this.deps.log(`auto-update: ${errText(err)}`);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+}
+exports.AutoUpdater = AutoUpdater;
+function errText(err) {
+    return err instanceof Error ? err.message : String(err);
+}

package/dist/channel/permission.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PermissionRelay = exports.RELAY_OPTIONS = void 0;
 exports.composeRelayQuestion = composeRelayQuestion;
+const waiting_cards_1 = require("../waiting-cards");
 /** Button labels, and the ONLY index that means yes. Same as `baychat approve-hook`. */
 exports.RELAY_OPTIONS = ["Allow this once", "Deny"];
 const ALLOW_INDEX = 0;
@@ -40,6 +41,7 @@ class PermissionRelay {
             return; // Nobody is listening through this channel: the terminal alone decides.
         const pending = { claudeId: req.request_id, login: target.login, retired: false };
         this.current = pending;
+        let unmark = () => undefined;
         try {
             let reply = await this.deps.api(target.login, "POST", "/api/device-api/approvals", {
                 session: target.session,
@@ -55,6 +57,9 @@ class PermissionRelay {
                 this.deps.log("permission relay: BayChat returned no card id");
                 return;
             }
+            // Marked while the card waits, so the relay's automatic update never restarts BayChat
+            // under an open question (waiting-cards.ts).
+            unmark = (0, waiting_cards_1.markWaitingCard)(pending.cardId);
             let failures = 0;
             for (;;) {
                 if (pending.retired) {
@@ -87,6 +92,7 @@ class PermissionRelay {
             this.deps.log(`permission relay: could not ask BayChat (${err instanceof Error ? err.message : String(err)}); the terminal still decides`);
         }
         finally {
+            unmark();
             if (this.current === pending)
                 this.current = undefined;
         }

package/dist/cli-help.js

@@ -29,7 +29,12 @@ Usage:
   baychat update                        Bring this machine onto the current version —
                                         the package, every connected client's config, and
                                         the relay daemon (which otherwise keeps running
-                                        old code). \`baychat\` does this for you once a day
+                                        old code). The relay does this by itself about
+                                        once a day, in a quiet moment, and asks on your
+                                        phone first when a version needs you
+  baychat update --auto on|off          Switch those automatic updates on or off for this
+                                        computer (default on; BAYCHAT_AUTO_UPDATE=0 also
+                                        turns them off)
   baychat join [name] [group] [--sessions | --private | --group <title>] [--runtime <runtime>] [--bay <Bay>]
   baychat join --session <name> --group <title> --runtime codex
                                         Join and connect incoming messages in this terminal
@@ -159,6 +164,17 @@ Usage:
                                         docs/features/REMOTE_APPROVAL_HOOK.md before
                                         switching it on, because it moves the last line
                                         between an agent and this machine onto a phone
+  baychat denied-hook [--session <name> | --session-from-claude] [--timeout <sec>]
+                                        Claude Code PermissionDenied hook: when auto
+                                        mode blocks a call, put a card in BayChat; on
+                                        your yes, write that exact allow rule to the
+                                        project's .claude/settings.local.json and let
+                                        the session retry. Prints the retry or nothing;
+                                        every error leaves the denial standing
+  baychat permissions [list | remove <id> | on | off]
+                                        The denied-command card: on/off for sessions
+                                        BayChat starts (OFF by default), and the rules
+                                        it kept. See docs/features/DENIED_COMMAND_CARD.md
   baychat relay attach --session <name> [--runtime claude|codex|hermes]
                         [--resume-id <id>] [--timeout <sec>]
                                         Register this session with the relay and block
@@ -206,10 +222,21 @@ function helpRequest(command, args) {
  * Commands whose arguments belong to someone else, so `--help` among them is data:
  * - `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;
+ * - `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;
  * - `help` (and its spellings) already prints help, and its arguments are a question.
  */
-const ARGS_ARE_NOT_OURS = new Set(["claude", "send", "search", "approve-hook", "help", "--help", "-h"]);
+const ARGS_ARE_NOT_OURS = new Set([
+    "claude",
+    "send",
+    "search",
+    "approve-hook",
+    "denied-hook",
+    "denied-after",
+    "help",
+    "--help",
+    "-h",
+]);
 /** Commands with a usage of their own, fuller than their lines in `HELP`. */
 const OWN_USAGE = { login: exports.LOGIN_HELP, bays: bays_command_1.BAYS_USAGE, launch: command_1.LAUNCH_USAGE };
 /**

package/dist/denied/after-hook.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.afterCall = afterCall;
+exports.cmdDeniedAfter = cmdDeniedAfter;
+// `baychat denied-after` — the PostToolUse / PostToolUseFailure hook that takes an "Allow once"
+// rule back out as soon as the retried call has run.
+//
+// It is installed beside `denied-hook` (relay/launcher/approval-settings.ts) as an ASYNC hook:
+// Claude Code starts it and moves on, so it adds nothing to any tool call's latency, and it prints
+// nothing. It runs on every matching tool call, so it is routed by index.ts without loading the
+// CLI, and it returns at once when no once-grant exists — the common case by far.
+//
+// The TTL sweep (grants.ts, ONCE_TTL_MS) is the backstop for a retried call that never finishes,
+// and every run here sweeps too — including a grant whose deferred confirmation never finished,
+// which is taken back and the owner told (confirm.ts; it loads only the card client and config,
+// no MCP SDK and none of the CLI's commands).
+const hook_stdin_1 = require("../hook-stdin");
+const confirm_1 = require("./confirm");
+const grants_1 = require("./grants");
+const permission_rule_1 = require("./permission-rule");
+/** Handle one finished call. NEVER THROWS; diagnostics go to stderr. */
+async function afterCall(rawStdin, log = defaultLog) {
+    try {
+        if (!(0, grants_1.hasGrantsToSweep)())
+            return;
+        const input = JSON.parse(rawStdin);
+        const call = typeof input.tool_name === "string" ? (0, permission_rule_1.callKeyOf)(input.tool_name, input.tool_input) : undefined;
+        if (call && typeof input.session_id === "string")
+            await (0, grants_1.consumeOnceGrants)(input.session_id, call);
+        await (0, grants_1.sweepExpiredGrants)();
+        if ((0, grants_1.hasStaleUnconfirmed)()) {
+            await (0, confirm_1.takeBackStaleUnconfirmed)({ log });
+        }
+    }
+    catch (err) {
+        log(`baychat denied-after: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function defaultLog(line) {
+    process.stderr.write(`${line}\n`);
+}
+/** The command. Always 0: nothing this hook could say would change the call that already ran. */
+async function cmdDeniedAfter(stdin = process.stdin) {
+    await afterCall(await (0, hook_stdin_1.readStdin)(stdin, 5_000));
+    return 0;
+}

package/dist/denied/confirm.js

@@ -0,0 +1,131 @@
+"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.confirmGrant = confirmGrant;
+exports.takeBackStaleUnconfirmed = takeBackStaleUnconfirmed;
+// `baychat permissions confirm --grant <id>` — the deferred half of the denied-command card's proof.
+//
+// Claude Code 2.1.299 writes a denied call to the transcript only after the PermissionDenied hook
+// returns (transcript.ts), so the hook accepts such a call on the live-session proof
+// (live-session.ts) and records the owner's grant as UNCONFIRMED. Just before printing `retry` it
+// starts this command detached (like `permissions sweep`), which polls the transcript for the
+// original `tool_use_id` for up to CONFIRM_WAIT_MS:
+//
+//   • found, and the same call → the grant is marked confirmed and stands;
+//   • not found, or another call under that id → the grant's rules are taken back out of the file
+//     they went into, and the owner gets an info card saying so.
+//
+// A confirmation that never finishes (the child killed, the computer asleep) is caught by the next
+// run of either hook or of a sweep: an unconfirmed grant older than UNCONFIRMED_STALE_MS is taken
+// back the same way (`takeBackStaleUnconfirmed`).
+const os = __importStar(require("os"));
+const approval_wait_1 = require("../approval-wait");
+const config_1 = require("../config");
+const grants_1 = require("./grants");
+const notice_1 = require("./notice");
+const transcript_1 = require("./transcript");
+const LOG_LABEL = "baychat permissions confirm";
+/** Confirm grant `id` against the transcript, or take it back. NEVER THROWS. */
+async function confirmGrant(id, deps = {}) {
+    const log = deps.log ?? ((line) => process.stderr.write(`${line}\n`));
+    try {
+        const grant = (0, grants_1.findGrant)(id);
+        if (!grant) {
+            log(`${LOG_LABEL}: grant ${id} is already gone; nothing to confirm.`);
+            return "missing";
+        }
+        const pending = grant.unconfirmed;
+        if (!pending) {
+            log(`${LOG_LABEL}: grant ${id} was proven up front; nothing to confirm.`);
+            return "not-pending";
+        }
+        const verify = deps.verify ?? ((ref) => (0, transcript_1.verifyDeniedCall)(ref, { waitMs: transcript_1.CONFIRM_WAIT_MS }));
+        const verdict = await verify({
+            transcriptPath: pending.transcriptPath,
+            agentId: pending.agentId,
+            toolUseId: pending.toolUseId,
+            toolName: pending.toolName,
+            call: grant.call,
+        });
+        if (verdict.ok) {
+            const still = await (0, grants_1.markConfirmed)(id);
+            log(`${LOG_LABEL}: grant ${id} confirmed — the call is in the session's transcript${still ? "" : " (its once-rule was already used and removed)"}.`);
+            return "confirmed";
+        }
+        const revoked = await (0, grants_1.revokeGrant)(id);
+        log(`${LOG_LABEL}: grant ${id} NOT confirmed (${verdict.why}); ${revoked ? "its rules were removed" : "it was already gone"}.`);
+        // A once-grant gone by now was used by the retried call: the owner still has to hear of it.
+        if (revoked || grant.kind === "once")
+            await notifyOwner([{ grant, why: verdict.why, used: !revoked }], deps, log);
+        return "revoked";
+    }
+    catch (err) {
+        log(`${LOG_LABEL}: grant ${id} could not be confirmed (${(0, approval_wait_1.reasonOf)(err)}); a later hook run takes it back when it goes stale.`);
+        return "missing";
+    }
+}
+/** Take back every unconfirmed grant whose confirmation should have finished, and tell the owner.
+ *  Returns how many. NEVER THROWS. */
+async function takeBackStaleUnconfirmed(deps = {}) {
+    const log = deps.log ?? ((line) => process.stderr.write(`${line}\n`));
+    try {
+        const doomed = await (0, grants_1.sweepStaleUnconfirmed)((deps.now ?? Date.now)());
+        for (const grant of doomed)
+            log(`${LOG_LABEL}: grant ${grant.id} was never confirmed in time; its rules were removed.`);
+        if (doomed.length)
+            await notifyOwner(doomed.map((grant) => ({ grant, why: "its confirmation never finished", used: false })), deps, log);
+        return doomed.length;
+    }
+    catch (err) {
+        log(`${LOG_LABEL}: stale unconfirmed grants could not be swept (${(0, approval_wait_1.reasonOf)(err)}).`);
+        return 0;
+    }
+}
+async function notifyOwner(items, deps, log) {
+    const device = (deps.loadDevice ?? config_1.loadDeviceCredentials)();
+    if (!device) {
+        log(`${LOG_LABEL}: not logged in to BayChat, so the owner could not be told.`);
+        return;
+    }
+    const noticeDeps = {
+        now: deps.now ?? Date.now,
+        sleep: deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms))),
+        log,
+    };
+    const host = (deps.hostname ?? os.hostname)();
+    for (const { grant, why, used } of items) {
+        await (0, notice_1.postNotice)(device, grant.session, (0, notice_1.unconfirmedNotice)(grant, host, why, used), noticeDeps, LOG_LABEL);
+    }
+}