@astrofoundry/pi-astro 0.32.0 → 0.33.1

package/extensions/astro-discord/index.ts

@@ -1,5 +1,6 @@
-import { execFile } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { loadConfig as loadSpecialists } from "../specialist-gate/config.ts";
 import { APPROVAL_TOKEN_ENV, APPROVAL_URL_ENV } from "../specialist-gate/index.ts";
@@ -10,13 +11,46 @@ import { ApprovalServer, type Ticket } from "./approvals.ts";
 import { chunkMessage } from "./chunk.ts";
 import { applyAdminCommand } from "./admin.ts";
 import { CHANNEL_RULES, helpText, needsPrefixText, parseCommand } from "./commands.ts";
-import { ACTIVATION_ENV, type ChannelSettings, type DiscordConfig, allowedSpecialists, canUse, channelSpecialists, isOwner, loadConfig, loadToken, saveConfig } from "./config.ts";
+import { ACTIVATION_ENV, type ChannelSettings, type DiscordConfig, type ReportName, type ReportSchedule, allowedSpecialists, canUse, channelSpecialists, isOwner, loadConfig, loadToken, reportSchedule, saveConfig } from "./config.ts";
 import { type ConversationState, type ResolvedConversation, forgetStale, loadState, newConversationId, recordAnswer, resolveConversation, saveState, sessionsRoot, startConversation } from "./conversations.ts";
 import { describeImages, downloadImages, type ImageAttachment, imageAttachments } from "./attachments.ts";
-import { failureMessage, formatDailyReport, isDue, readReportState, writeReportState } from "./daily-report.ts";
+import { failureMessage, formatDailyReport } from "./daily-report.ts";
 import { GatewayClient } from "./gateway.ts";
 import { type CommandOption, IS_COMPONENTS_V2, KeyedQueue, MEDIA, MEDIA_COMMANDS, type MediaKind, type Outcome, addOutcome, applyOutcome, commandArgs, hasActiveButton, listMessage, mediaAccess, mediaPointer, parseAddButton, parseAddReport, parseMediaList, parseQueueState, queueLine } from "./media.ts";
 import { cancelledApprovalText, interruptedTaskText, readOpenWork, type OpenWork, type StopReason, writeOpenWork } from "./open-work.ts";
+import { isDue, readReportState, writeReportState } from "./reports.ts";
+import { ACTIVITY_COMMAND, type Activity, addRestarts, astrogateActivity, herdrActivity, needsPrompt, type PendingRestart, readRestarts, restartCommand, SERVICE_LABEL, SERVICE_ORDER, writeRestarts } from "./restarts.ts";
+import {
+    arcaneServerVersion,
+    BREW_ALL,
+    brewHasOutdated,
+    buildLines,
+    collectTools,
+    type Exec,
+    failureText,
+    layoutMessages,
+    type LineState,
+    messageComponents,
+    notesFor,
+    parseToolsButton,
+    parseVerdict,
+    readPackageVersion,
+    readPostedReport,
+    REVIEW_SOURCES,
+    type Review,
+    reviewPrompt,
+    rollbackCommand,
+    type Service,
+    servicesFor,
+    TOOL_PATH,
+    type ToolLine,
+    type ToolsButton,
+    type ToolsReport,
+    updateCommand,
+    verifiedVersion,
+    verifyCommand,
+    writePostedReport,
+} from "./tools-report.ts";
 import { type Quote, type QuotedMessage, withQuotes } from "./quote.ts";
 import { DiscordRest, type MessageComponent } from "./rest.ts";
 
@@ -95,6 +129,11 @@ const MEDIA_MESSAGE_CACHE = 100;
 /** Upper bound for one media wrapper call from Discord; a single add or list takes seconds. */
 const MEDIA_TIMEOUT_MS = 3 * 60_000;
 const EPHEMERAL = 64;
+/** The release Pi has installed: the package this bridge runs from, read from disk so an update shows at once. */
+const PACKAGE_JSON = fileURLToPath(new URL("../../package.json", import.meta.url));
+/** Upper bound for one tool update from an Update button; `brew upgrade` of everything can take a while. */
+const UPDATE_TIMEOUT_MS = 30 * 60_000;
+const REVIEWER = "astro.release-reviewer";
 
 interface ActiveTask {
     specialist: string;
@@ -141,9 +180,13 @@ class Bridge {
     private readonly mediaRuns = new Map<string, MediaRun>();
     private readonly mediaClicks = new KeyedQueue();
     private readonly mediaMessages = new Map<string, MessageComponent[]>();
+    /** Tool updates started from the Cortex Tools Report, by line key; they count as open work. */
+    private readonly toolRuns = new Map<string, { channelId: string; label: string }>();
+    private readonly toolClicks = new KeyedQueue();
     private gateway: GatewayClient | undefined;
     private stopping = false;
-    private reportRunning = false;
+    private readonly reportsRunning = new Set<ReportName>();
+    private restartsRunning = false;
     private reportTimer: NodeJS.Timeout | undefined;
     private readonly since = new Date().toISOString();
     private config: DiscordConfig;
@@ -183,6 +226,7 @@ class Bridge {
             tasks: [
                 ...[...this.active.values()].map((t) => ({ specialist: t.specialist, channelId: t.channelId, messageId: t.messageId, ...(t.placeholder ? { placeholderId: t.placeholder } : {}) })),
                 ...[...this.mediaRuns.values()].map((r) => ({ specialist: MEDIA, channelId: r.channelId })),
+                ...[...this.toolRuns.values()].map((r) => ({ specialist: "tools", channelId: r.channelId })),
             ],
             approvals: [...this.approvalMessages.entries()].map(([ticketId, a]) => ({ ticketId, channelId: a.channelId, messageId: a.messageId, userChannelId: a.userMessage.channelId, userMessageId: a.userMessage.messageId })),
         };
@@ -229,7 +273,10 @@ class Bridge {
         for (const task of this.active.values()) task.abort?.abort();
         if (work.tasks.length > 0 || work.approvals.length > 0) log(`shutdown: cancelling ${work.approvals.length} approval(s), interrupting ${work.tasks.length} task(s)`);
         // Media runs are answered through their own interaction instead of a new channel message.
-        const answers = [...this.mediaRuns.values()].map((r) => this.answerInterruptedMedia(r).catch(() => undefined));
+        const answers = [
+            ...[...this.mediaRuns.values()].map((r) => this.answerInterruptedMedia(r).catch(() => undefined)),
+            ...[...this.toolRuns.values()].map((r) => this.rest.createMessage(r.channelId, { content: `❌ The update of ${r.label} was interrupted: the bridge restarted. Its line in the report says what to do next.` }).catch(() => undefined)),
+        ];
         await Promise.all([this.closeOpen({ ...work, tasks: work.tasks.filter((t) => t.messageId !== undefined) }, "restart"), ...answers]);
         this.approvals.close();
         writeOpenWork({ since: this.since, tasks: [], approvals: [] });
@@ -256,10 +303,14 @@ class Bridge {
         gateway.start();
         this.gateway = gateway;
         void this.registerMediaCommands();
-        // Checked every minute; the report itself decides whether today's is due.
-        this.reportTimer = setInterval(() => void this.maybeDailyReport(), 60_000);
+        await this.closeInterruptedUpdates();
+        // Checked every minute: each report decides whether today's is due, and waiting restarts check whether their service is idle.
+        this.reportTimer = setInterval(() => {
+            void this.maybeReports();
+            void this.processRestarts();
+        }, 60_000);
         this.reportTimer.unref();
-        void this.maybeDailyReport();
+        void this.maybeReports();
         log(`connected as ${me.username} (${me.id}); channels ${Object.keys(this.config.channels).join(", ")}; specialists ${this.specialists().names.join(", ")}`);
     }
 
@@ -353,49 +404,346 @@ class Bridge {
         this.queues.set(command.specialist, next);
     }
 
+    /** Every configured report that is due today and not already running; each records its date before the post, so a crash during delivery never repeats it. */
+    private async maybeReports(): Promise<void> {
+        if (this.stopping) return;
+        this.refreshConfig();
+        for (const schedule of this.config.reports) {
+            if (this.reportsRunning.has(schedule.report)) continue;
+            const { due, date } = isDue(schedule, readReportState(schedule.report), new Date());
+            if (!due) continue;
+            this.reportsRunning.add(schedule.report);
+            const run = schedule.report === "arcane" ? this.arcaneReport(schedule, date) : this.toolsReport(schedule, date);
+            void run
+                .catch((err) => log(`${schedule.report} report ${date}: ${err instanceof Error ? err.message : String(err)}`))
+                .finally(() => this.reportsRunning.delete(schedule.report));
+        }
+    }
+
+    /** The Arcane version report through the specialist wrapper, without a model, posted with its prefix. */
+    private async arcaneReport(schedule: ReportSchedule, date: string): Promise<void> {
+        if (!loadSpecialists().config) {
+            log("arcane report: specialists.json missing; no report");
+            return;
+        }
+        log(`arcane report ${date}: running arcane update-report`);
+        let message: { content: string; attachment?: string };
+        try {
+            const stdout = await this.runEntry("arcane", "daily-report", ["update-report"], 15 * 60_000);
+            message = formatDailyReport(JSON.parse(stdout), schedule.timeZone);
+        } catch (err) {
+            log(`arcane report ${date}: check failed: ${err instanceof Error ? err.message.slice(0, 500) : String(err)}`);
+            message = { content: failureMessage() };
+        }
+        if (this.stopping) return;
+        writeReportState("arcane", { date, status: "sending" });
+        const posted = await this.rest.createMessage(schedule.channelId, {
+            content: message.content,
+            ...(message.attachment ? { file: { name: `arcane-daily-report-${date}.txt`, content: message.attachment } } : {}),
+        });
+        writeReportState("arcane", { date, status: message.content === failureMessage() ? "failed" : "sent", messageId: posted.id });
+        log(`arcane report ${date}: posted ${posted.id}`);
+    }
+
+    /** Runs a program with an argument list as this user, never through a shell; resolves even on failure. */
+    private readonly execTool: Exec = (file, args, options) =>
+        new Promise((resolve) => {
+            execFile(file, args, { timeout: options.timeoutMs, maxBuffer: 50 * 1024 * 1024, env: { ...process.env, ...options.env } }, (err, stdout, stderr) => {
+                const code = err ? (typeof (err as { code?: unknown }).code === "number" ? (err as { code: number }).code : 1) : 0;
+                resolve({ code, stdout: String(stdout), stderr: String(stderr) || (err ? err.message : "") });
+            });
+        });
+
     /**
-     * Runs the Arcane version report through the specialist wrapper, without a
-     * model, and posts it with the prefix. One message per local date: the date
-     * is recorded before the post, so a crash during delivery never repeats it.
+     * The Cortex Tools Report: every tool with a newer version, a release-notes
+     * review for the tools we build on, and an Update button per line. Nothing
+     * is installed until an owner presses one.
      */
-    private async maybeDailyReport(): Promise<void> {
-        if (this.reportRunning || this.stopping) return;
+    private async toolsReport(schedule: ReportSchedule, date: string): Promise<void> {
+        log(`tools report ${date}: collecting`);
+        let report: ToolsReport;
+        try {
+            const collected = await collectTools({
+                exec: this.execTool,
+                fetchImpl: fetch,
+                piAstroPackage: PACKAGE_JSON,
+                arcaneServer: async () => arcaneServerVersion(JSON.parse(await this.runEntry("arcane", "tools-report", ["version"], 2 * 60_000))),
+            });
+            const lines = buildLines(collected);
+            for (const line of lines) if (REVIEW_SOURCES[line.key] && !this.stopping) line.review = await this.reviewLine(line);
+            report = { date, checkedAt: new Date().toISOString(), channelId: schedule.channelId, timeZone: schedule.timeZone, lines, warnings: collected.warnings, brewOutdated: brewHasOutdated(collected.brewOutdated), brewAll: "offered", messages: [] };
+        } catch (err) {
+            log(`tools report ${date}: check failed: ${err instanceof Error ? err.message.slice(0, 500) : String(err)}`);
+            if (this.stopping) return;
+            writeReportState("tools", { date, status: "sending" });
+            const posted = await this.rest.createMessage(schedule.channelId, { content: failureText() });
+            writeReportState("tools", { date, status: "failed", messageId: posted.id });
+            return;
+        }
+        if (this.stopping) return;
+        writeReportState("tools", { date, status: "sending" });
+        for (const page of layoutMessages(report)) {
+            const posted = await this.rest.createComponentsMessage(schedule.channelId, messageComponents(report, page));
+            report.messages.push({ id: posted.id, ...page });
+        }
+        writePostedReport(report);
+        writeReportState("tools", { date, status: "sent", messageId: report.messages[0]?.id });
+        log(`tools report ${date}: ${report.lines.length} update(s) in ${report.messages.length} message(s)`);
+    }
+
+    /** The release-notes verdict of one line from the tool-less reviewer agent; the notes reach it only as task text. */
+    private async reviewLine(line: ToolLine): Promise<Review> {
+        const notes = await notesFor(line, fetch);
+        if (notes.notes === null) return { verdict: null, reason: notes.reason };
+        const agent = this.specialists().agents.find((a) => a.name === REVIEWER);
+        if (!agent) return { verdict: null, reason: `${REVIEWER} is not installed` };
+        const { depth } = currentDepth();
+        try {
+            const result = await runAgent({
+                agent,
+                skills: [],
+                task: reviewPrompt(line, notes.notes, notes.omitted),
+                cwd: process.cwd(),
+                depth,
+                remaining: 0,
+                defaults: { model: this.ctx.model ? `${this.ctx.model.provider}/${this.ctx.model.id}` : undefined, thinkingLevel: this.ctx.thinkingLevel },
+                env: { [ACTIVATION_ENV]: "0" },
+            });
+            const verdict = isFailed(result) ? null : parseVerdict(finalOutput(result.messages));
+            log(`tools report: reviewed ${line.label} ${line.installed} -> ${line.latest}: ${verdict?.verdict ?? "no answer"}`);
+            return verdict ?? { verdict: null, reason: "the review gave no usable answer; read the notes before updating" };
+        } catch (err) {
+            return { verdict: null, reason: `the review failed: ${err instanceof Error ? err.message.slice(0, 120) : String(err)}` };
+        }
+    }
+
+    /** Lines a crash or restart left "updating" can be pressed again; their message says so. */
+    private async closeInterruptedUpdates(): Promise<void> {
+        const report = readPostedReport();
+        if (!report) return;
+        const interrupted = report.lines.filter((l) => l.state === "running");
+        if (interrupted.length === 0 && report.brewAll !== "running") return;
+        for (const l of interrupted) {
+            l.state = "failed";
+            l.detail = "interrupted by a bridge restart; check the version before pressing Retry";
+        }
+        if (report.brewAll === "running") {
+            report.brewAll = "failed";
+            report.brewAllDetail = "interrupted by a bridge restart";
+        }
+        writePostedReport(report);
+        for (const m of report.messages) await this.rest.editComponents(report.channelId, m.id, messageComponents(report, m)).catch(() => undefined);
+    }
+
+    private async redrawLine(report: ToolsReport, key: string | null): Promise<void> {
+        const m = report.messages.find((x) => (key === null ? x.all : x.keys.includes(key)));
+        if (m) await this.rest.editComponents(report.channelId, m.id, messageComponents(report, m)).catch((err) => log(`tools report: redraw failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+
+    /** Update, Upgrade everything, and Restart now buttons: owners only, checked against the report the bridge posted. */
+    private async onToolsButton(interaction: Interaction, customId: string): Promise<void> {
+        const button = parseToolsButton(customId);
+        const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "";
         this.refreshConfig();
-        const settings = this.config.dailyReport;
-        if (!settings) return;
-        const { due, date } = isDue(settings, readReportState(), new Date());
-        if (!due) return;
-        const gate = loadSpecialists().config;
-        if (!gate) {
-            log("daily report: specialists.json missing; no report");
+        if (!button) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, "This button is no longer active.");
             return;
         }
-        this.reportRunning = true;
+        if (!isOwner(this.config, userId)) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, "Only owners update tools or restart services.");
+            return;
+        }
+        if (this.stopping) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, "The bridge is restarting; try again in a minute.");
+            return;
+        }
+        if (button.kind === "restart") {
+            await this.onRestartNow(interaction, button.service, userId);
+            return;
+        }
+        const report = readPostedReport();
+        const posted = report?.messages.find((m) => m.id === interaction.message?.id);
+        if (!report || !posted) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, "This report is outdated; use the newest Cortex Tools Report.");
+            return;
+        }
+        const state = button.kind === "all" ? (button.date === report.date && posted.all ? report.brewAll : null) : (report.lines.find((l) => l.key === button.key && l.latest === button.version && posted.keys.includes(l.key))?.state ?? null);
+        if (state === null) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, "This update is no longer offered.");
+            return;
+        }
+        if (state === "running" || state === "updated") {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, state === "running" ? "This update is already running." : "This update is already done.");
+            return;
+        }
+        await this.rest.deferUpdate(interaction.id, interaction.token);
+        await this.toolClicks.run("tools", () => this.runToolUpdate(button, userId)).catch((err) => log(`tools update failed: ${err instanceof Error ? err.message : String(err)}`));
+    }
+
+    /** One update, one at a time: run the fixed command, read the version back, roll back where possible, then mark the line. */
+    private async runToolUpdate(button: Exclude<ToolsButton, { kind: "restart" }>, userId: string): Promise<void> {
+        const report = readPostedReport();
+        if (!report) return;
+        const target = button.kind === "update" ? report.lines.find((l) => l.key === button.key && l.latest === button.version) : undefined;
+        if (button.kind === "update" && (!target || target.state === "updated" || target.state === "running")) return;
+        if (button.kind === "all" && (report.brewAll === "updated" || report.brewAll === "running")) return;
+        const key = target?.key ?? null;
+        const label = target ? `${target.label} ${target.latest}` : "every outdated Homebrew package";
+        const mark = (r: ToolsReport, state: LineState, detail?: string) => {
+            const l = key === null ? undefined : r.lines.find((x) => x.key === key);
+            if (l) {
+                l.state = state;
+                l.detail = detail;
+            } else if (key === null) {
+                r.brewAll = state;
+                r.brewAllDetail = detail;
+            }
+        };
+        mark(report, "running");
+        writePostedReport(report);
+        await this.redrawLine(report, key);
+        this.toolRuns.set(key ?? "brew-all", { channelId: report.channelId, label });
+        this.saveOpenWork();
+        log(`tools: updating ${label} for ${userId}`);
+        let ok = false;
+        let detail = "";
+        // Homebrew upgrades dependencies with the package, so Node can change under the bridge and Astrogate.
+        const viaBrew = !target || target.action.kind === "brew" || target.action.kind === "cask";
+        const nodeBefore = viaBrew ? await this.brewNodeVersion() : "";
         try {
-            log(`daily report ${date}: running arcane update-report`);
-            let message: { content: string; attachment?: string };
-            try {
-                const stdout = await this.runEntry("arcane", "daily-report", ["update-report"], 15 * 60_000);
-                message = formatDailyReport(JSON.parse(stdout), settings.timeZone);
-            } catch (err) {
-                log(`daily report ${date}: check failed: ${err instanceof Error ? err.message.slice(0, 500) : String(err)}`);
-                message = { content: failureMessage() };
+            const command = target ? updateCommand(target.action, target.latest) : BREW_ALL;
+            const r = await this.execTool(command.file, command.args, { timeoutMs: UPDATE_TIMEOUT_MS, env: { PATH: TOOL_PATH } });
+            if (!target) {
+                ok = r.code === 0;
+                if (!ok) detail = `brew upgrade failed: ${r.stderr.trim().split("\n").pop()?.slice(0, 200) || `exit ${r.code}`}`;
+            } else {
+                const verify = verifyCommand(target.action);
+                if (r.code !== 0) detail = r.stderr.trim().split("\n").pop()?.slice(0, 200) || `exit ${r.code}`;
+                else if (!verify) ok = readPackageVersion(PACKAGE_JSON) === target.latest;
+                else {
+                    const v = await this.execTool(verify.file, verify.args, { timeoutMs: 2 * 60_000, env: { PATH: TOOL_PATH, HOMEBREW_NO_AUTO_UPDATE: "1" } });
+                    ok = v.code === 0 && verifiedVersion(target.action, v.stdout, target.latest);
+                }
+                if (!ok && r.code === 0) detail = `the command finished, but ${target.latest} is not what is installed now`;
+                if (!ok) {
+                    const rollback = rollbackCommand(target.action, target.installed);
+                    if (rollback) {
+                        const rb = await this.execTool(rollback.file, rollback.args, { timeoutMs: UPDATE_TIMEOUT_MS, env: { PATH: TOOL_PATH } });
+                        detail += rb.code === 0 ? `; rolled back to ${target.installed}` : `; rollback to ${target.installed} failed`;
+                    } else if (target.action.kind === "brew" || target.action.kind === "cask") {
+                        detail += `; Homebrew cannot downgrade, \`brew pin ${target.action.kind === "brew" ? target.action.name : target.action.token}\` holds a version`;
+                    }
+                }
             }
-            if (this.stopping) return;
-            writeReportState({ date, status: "sending" });
-            const posted = await this.rest.createMessage(settings.channelId, {
-                content: message.content,
-                ...(message.attachment ? { file: { name: `arcane-daily-report-${date}.txt`, content: message.attachment } } : {}),
-            });
-            writeReportState({ date, status: message.content === failureMessage() ? "failed" : "sent", messageId: posted.id });
-            log(`daily report ${date}: posted ${posted.id}`);
         } catch (err) {
-            log(`daily report ${date}: delivery failed: ${err instanceof Error ? err.message : String(err)}`);
+            detail = err instanceof Error ? err.message : String(err);
+        } finally {
+            this.toolRuns.delete(key ?? "brew-all");
+            this.saveOpenWork();
+        }
+        const current = readPostedReport();
+        const fresh = current && current.date === report.date ? current : report;
+        mark(fresh, ok ? "updated" : "failed", ok ? undefined : detail.slice(0, 300));
+        if (fresh === current) writePostedReport(fresh);
+        await this.redrawLine(fresh, key);
+        log(`tools: ${label} ${ok ? "updated" : `failed: ${detail}`}`);
+        if (!ok) return;
+        const services = servicesFor(target ? target.action : "brew-all");
+        if (viaBrew && (await this.brewNodeVersion()) !== nodeBefore) services.push("astrogate", "bridge");
+        if (services.length > 0) writeRestarts(addRestarts(readRestarts(), [...new Set(services)], label, new Date()));
+    }
+
+    private async brewNodeVersion(): Promise<string> {
+        return (await this.execTool("/opt/homebrew/bin/node", ["--version"], { timeoutMs: 30_000 })).stdout.trim();
+    }
+
+    private bridgeActivity(): Activity {
+        const running = [
+            ...[...this.active.values()].map((t) => `${t.specialist} task for <@${t.userId}>`),
+            ...(this.approvalMessages.size > 0 ? [`${this.approvalMessages.size} approval request(s)`] : []),
+            ...(this.mediaRuns.size > 0 ? [`${this.mediaRuns.size} media command(s)`] : []),
+            ...[...this.toolRuns.values()].map((r) => `update of ${r.label}`),
+            ...[...this.reportsRunning].map((name) => `the ${name} report`),
+        ];
+        return { idle: running.length === 0, running };
+    }
+
+    private async serviceActivity(service: Service): Promise<Activity> {
+        if (service === "bridge") return this.bridgeActivity();
+        const command = ACTIVITY_COMMAND[service];
+        const r = await this.execTool(command.file, command.args, { timeoutMs: 60_000, env: { PATH: TOOL_PATH } });
+        return service === "herdr" ? herdrActivity(r.code, r.stdout, r.stderr) : astrogateActivity(r.code, r.stdout, r.stderr);
+    }
+
+    private restartChannel(): string {
+        return reportSchedule(this.config, "tools")?.channelId ?? this.config.adminChannelId;
+    }
+
+    /** Restarts each waiting service once nothing runs on it; after a day of waiting, offers a Restart now button instead. */
+    private async processRestarts(): Promise<void> {
+        if (this.restartsRunning || this.stopping || this.toolRuns.size > 0) return;
+        let pending = readRestarts();
+        if (pending.length === 0) return;
+        this.restartsRunning = true;
+        try {
+            for (const service of SERVICE_ORDER) {
+                const p = pending.find((x) => x.service === service);
+                if (!p) continue;
+                const activity = await this.serviceActivity(service);
+                if (activity.idle) {
+                    pending = pending.filter((x) => x !== p);
+                    writeRestarts(pending);
+                    await this.restartService(p, null);
+                    continue;
+                }
+                if (needsPrompt(p, new Date())) {
+                    const content = `⏳ ${SERVICE_LABEL[service]} has waited a day to restart for ${p.reasons.join(", ")}. Still running: ${activity.running.join("; ")}. Restart now stops them.`;
+                    const posted = await this.rest.createMessage(this.restartChannel(), {
+                        content: content.slice(0, 1900),
+                        components: [{ type: 1, components: [{ type: 2, style: 4, label: "Restart now", custom_id: `tools:restart:${service}` }] }],
+                    });
+                    p.prompt = { channelId: posted.channel_id, messageId: posted.id };
+                    writeRestarts(pending);
+                }
+            }
         } finally {
-            this.reportRunning = false;
+            this.restartsRunning = false;
         }
     }
 
+    /** Restarts one service; the bridge's own restart runs detached, because launchd stops this process with it. */
+    private async restartService(p: PendingRestart, byUser: string | null): Promise<void> {
+        const who = byUser ? ` by <@${byUser}>` : "";
+        const text = `♻️ Restarting ${SERVICE_LABEL[p.service]}${who} for ${p.reasons.join(", ")}.`;
+        if (p.prompt) await this.rest.editMessage(p.prompt.channelId, p.prompt.messageId, text, []).catch(() => undefined);
+        else await this.rest.createMessage(this.restartChannel(), { content: text.slice(0, 1900) }).catch(() => undefined);
+        const uid = process.getuid?.();
+        if (uid === undefined) {
+            log(`restart ${p.service}: this platform has no user id for launchctl; restart it by hand`);
+            return;
+        }
+        const command = restartCommand(p.service, uid);
+        log(`restart ${p.service}${byUser ? ` by ${byUser}` : ""}: ${command.args.join(" ")}`);
+        if (p.service === "bridge") {
+            spawn(command.file, command.args, { detached: true, stdio: "ignore" }).unref();
+            return;
+        }
+        const r = await this.execTool(command.file, command.args, { timeoutMs: 2 * 60_000, env: { PATH: TOOL_PATH } });
+        if (r.code !== 0) await this.rest.createMessage(this.restartChannel(), { content: `❌ Restarting ${SERVICE_LABEL[p.service]} failed: ${(r.stderr || r.stdout).trim().split("\n")[0]?.slice(0, 300)}. Restart it by hand.` }).catch(() => undefined);
+    }
+
+    private async onRestartNow(interaction: Interaction, service: Service, userId: string): Promise<void> {
+        const pending = readRestarts();
+        const p = pending.find((x) => x.service === service);
+        if (!p) {
+            await this.rest.ephemeralReply(interaction.id, interaction.token, `No restart of ${SERVICE_LABEL[service]} is waiting.`);
+            return;
+        }
+        await this.rest.deferUpdate(interaction.id, interaction.token);
+        writeRestarts(pending.filter((x) => x !== p));
+        await this.restartService(p, userId);
+    }
+
     /** Runs one specialist wrapper through the sudo entry point, without a model; rejects with the wrapper's stderr. */
     private runEntry(service: string, caller: string, args: string[], timeoutMs: number): Promise<string> {
         const gate = loadSpecialists().config;
@@ -688,6 +1036,10 @@ class Bridge {
             await this.onMediaButton(interaction, customId);
             return;
         }
+        if (customId.startsWith("tools:")) {
+            await this.onToolsButton(interaction, customId);
+            return;
+        }
         const match = /^apr:([0-9a-f-]{36}):(approve|deny)$/.exec(customId);
         if (!match) return;
         const userId = interaction.member?.user?.id ?? interaction.user?.id ?? "";

package/extensions/astro-discord/media.ts

@@ -164,7 +164,7 @@ export function parseQueueState(value: unknown): boolean | null {
 
 const IMDB_ID = /^tt\d{1,12}$/;
 
-function escapeDiscord(text: string): string {
+export function escapeDiscord(text: string): string {
     return text.replace(/([\\*_~`|[\]])/g, "\\$1");
 }
 

package/extensions/astro-discord/reports.ts

@@ -0,0 +1,49 @@
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir, type ReportName } from "./config.ts";
+
+export interface ReportState {
+    /** Local date in the report's time zone, `YYYY-MM-DD`. */
+    date: string;
+    status: "sending" | "sent" | "failed";
+    messageId?: string;
+}
+
+/** Local date and minutes past midnight in a time zone. */
+export function zonedNow(timeZone: string, now: Date): { date: string; minutes: number } {
+    const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(now);
+    const get = (type: string) => parts.find((p) => p.type === type)?.value ?? "";
+    return { date: `${get("year")}-${get("month")}-${get("day")}`, minutes: Number(get("hour")) * 60 + Number(get("minute")) };
+}
+
+/**
+ * Due once per local date, from the configured time on: a bridge that was down
+ * at the report's time posts when it comes back that day. Any record for today,
+ * even a failed or interrupted send, means no second message.
+ */
+export function isDue(schedule: { time: string; timeZone: string }, state: ReportState | null, now: Date): { due: boolean; date: string } {
+    const { date, minutes } = zonedNow(schedule.timeZone, now);
+    const [h, m] = schedule.time.split(":").map(Number);
+    return { due: minutes >= h * 60 + m && state?.date !== date, date };
+}
+
+/** The Arcane report keeps the file it had before reports became a list, so the switch never posts twice on one day. */
+function statePath(name: ReportName): string {
+    return join(configDir(), name === "arcane" ? "daily-report.json" : `${name}-report.json`);
+}
+
+export function readReportState(name: ReportName): ReportState | null {
+    try {
+        const raw = JSON.parse(readFileSync(statePath(name), "utf-8")) as Partial<ReportState>;
+        return typeof raw.date === "string" && typeof raw.status === "string" ? (raw as ReportState) : null;
+    } catch {
+        return null;
+    }
+}
+
+export function writeReportState(name: ReportName, state: ReportState): void {
+    const path = statePath(name);
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+    renameSync(tmp, path);
+}

package/extensions/astro-discord/rest.ts

@@ -81,6 +81,17 @@ export class DiscordRest {
         return (await this.call("POST", `/channels/${channelId}/messages`, JSON.stringify(payload), "application/json")).json() as Promise<DiscordMessage>;
     }
 
+    /** A Components V2 message (flag `1 << 15`): text lives in Text Display components, there is no `content`. */
+    async createComponentsMessage(channelId: string, components: MessageComponent[]): Promise<DiscordMessage> {
+        const payload = { flags: 1 << 15, components, allowed_mentions: { parse: [] } };
+        return (await this.call("POST", `/channels/${channelId}/messages`, JSON.stringify(payload), "application/json")).json() as Promise<DiscordMessage>;
+    }
+
+    /** Replaces the components of a Components V2 message; its flag stays set and needs no repeat. */
+    async editComponents(channelId: string, messageId: string, components: MessageComponent[]): Promise<void> {
+        await this.call("PATCH", `/channels/${channelId}/messages/${messageId}`, JSON.stringify({ components, allowed_mentions: { parse: [] } }), "application/json");
+    }
+
     async editMessage(channelId: string, messageId: string, content: string, components: MessageComponent[] = []): Promise<void> {
         await this.call("PATCH", `/channels/${channelId}/messages/${messageId}`, JSON.stringify({ content, components, allowed_mentions: { parse: [] } }), "application/json");
     }