@astrofoundry/pi-astro 0.32.0 → 0.33.0

package/extensions/astro-discord/restarts.ts

@@ -0,0 +1,109 @@
+import { readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir } from "./config.ts";
+import type { Command, Service } from "./tools-report.ts";
+
+/** A service that needs a restart before an update takes effect, waiting until nothing runs on it. */
+export interface PendingRestart {
+    service: Service;
+    /** When the first update that needs this restart finished. */
+    since: string;
+    /** What was updated, for the messages. */
+    reasons: string[];
+    /** The "Restart now" message posted after a day of waiting. */
+    prompt?: { channelId: string; messageId: string };
+}
+
+/** After this long a busy service gets a Restart now button, so an update is never stuck behind a session that never ends. */
+export const RESTART_WAIT_MS = 24 * 60 * 60_000;
+/** Herdr and Astrogate first: restarting the bridge ends this process. */
+export const SERVICE_ORDER: readonly Service[] = ["herdr", "astrogate", "bridge"];
+
+export const SERVICE_LABEL: Record<Service, string> = { bridge: "the Discord bridge", herdr: "herdr", astrogate: "Astrogate" };
+
+function path(): string {
+    return join(configDir(), "restarts.json");
+}
+
+export function readRestarts(): PendingRestart[] {
+    try {
+        const raw = JSON.parse(readFileSync(path(), "utf-8")) as unknown;
+        return Array.isArray(raw) ? (raw as PendingRestart[]).filter((p) => SERVICE_ORDER.includes(p.service) && typeof p.since === "string") : [];
+    } catch {
+        return [];
+    }
+}
+
+export function writeRestarts(pending: PendingRestart[]): void {
+    if (pending.length === 0) {
+        rmSync(path(), { force: true });
+        return;
+    }
+    const tmp = `${path()}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(pending, null, 2)}\n`, { mode: 0o600 });
+    renameSync(tmp, path());
+}
+
+/** Adds the services an update needs restarted; a service already waiting keeps its start time and gains the reason. */
+export function addRestarts(pending: readonly PendingRestart[], services: readonly Service[], reason: string, now: Date): PendingRestart[] {
+    const out = pending.map((p) => ({ ...p, reasons: [...p.reasons] }));
+    for (const service of services) {
+        const existing = out.find((p) => p.service === service);
+        if (existing) {
+            if (!existing.reasons.includes(reason)) existing.reasons.push(reason);
+        } else out.push({ service, since: now.toISOString(), reasons: [reason] });
+    }
+    return out.sort((a, b) => SERVICE_ORDER.indexOf(a.service) - SERVICE_ORDER.indexOf(b.service));
+}
+
+export function needsPrompt(p: PendingRestart, now: Date): boolean {
+    return !p.prompt && now.getTime() - new Date(p.since).getTime() >= RESTART_WAIT_MS;
+}
+
+/** What still runs on a service; an empty list means it may restart now. */
+export interface Activity {
+    idle: boolean;
+    running: string[];
+}
+
+/**
+ * `herdr agent list` prints `{ "result": { "agents": [...] } }`. A server
+ * restart stops every pane process, so any agent, idle or not, counts as running.
+ */
+export function herdrActivity(code: number, stdout: string, stderr: string): Activity {
+    if (code !== 0) return { idle: false, running: [`herdr agent list failed: ${(stderr || stdout).trim().split("\n")[0]?.slice(0, 120) ?? ""}`] };
+    let agents: unknown;
+    try {
+        agents = (JSON.parse(stdout) as { result?: { agents?: unknown } }).result?.agents;
+    } catch {
+        return { idle: false, running: ["herdr agent list printed no JSON"] };
+    }
+    if (!Array.isArray(agents)) return { idle: false, running: ["herdr agent list has no agents field"] };
+    const running = agents.map((a) => {
+        const r = a as { name?: unknown; pane_id?: unknown; state?: unknown; status?: unknown };
+        const who = typeof r.name === "string" ? r.name : typeof r.pane_id === "string" ? r.pane_id : "agent";
+        const state = typeof r.state === "string" ? r.state : typeof r.status === "string" ? r.status : "";
+        return state ? `${who} (${state})` : who;
+    });
+    return { idle: running.length === 0, running };
+}
+
+/** `astrogate status` prints exactly "No running sessions." when idle, otherwise one line per session. */
+export function astrogateActivity(code: number, stdout: string, stderr: string): Activity {
+    if (code !== 0) return { idle: false, running: [`astrogate status failed: ${(stderr || stdout).trim().split("\n")[0]?.slice(0, 120) ?? ""}`] };
+    const text = stdout.trim();
+    if (text === "No running sessions.") return { idle: true, running: [] };
+    return { idle: false, running: text.split("\n").map((l) => l.trim()).filter((l) => l.length > 0) };
+}
+
+export const ACTIVITY_COMMAND: Record<Exclude<Service, "bridge">, Command> = {
+    herdr: { file: "/opt/homebrew/bin/herdr", args: ["agent", "list"] },
+    astrogate: { file: "/opt/homebrew/bin/astrogate", args: ["status"] },
+};
+
+/** The restart for each service; the bridge's own runs detached because it ends this process. */
+export function restartCommand(service: Service, uid: number): Command {
+    if (service === "herdr") return { file: "/opt/homebrew/bin/brew", args: ["services", "restart", "herdr"] };
+    if (service === "astrogate") return { file: "/bin/launchctl", args: ["kickstart", "-k", `gui/${uid}/com.monadeo.astrogate`] };
+    return { file: "/bin/launchctl", args: ["kickstart", "-k", `gui/${uid}/com.astrofoundry.astro-discord`] };
+}

package/extensions/astro-discord/tools-report.test.ts

@@ -0,0 +1,344 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { countComponents } from "./media.ts";
+import { addRestarts, astrogateActivity, herdrActivity, needsPrompt, readRestarts, RESTART_WAIT_MS, restartCommand, SERVICE_ORDER, writeRestarts } from "./restarts.ts";
+import {
+    allId,
+    arcaneServerVersion,
+    brewHasOutdated,
+    buildLines,
+    type Collected,
+    collectTools,
+    compareLoose,
+    type Exec,
+    latestLts,
+    layoutMessages,
+    lineText,
+    majorChange,
+    messageComponents,
+    notesFor,
+    npmGlobalVersion,
+    parseToolsButton,
+    parseVerdict,
+    readPostedReport,
+    reviewPrompt,
+    rollbackCommand,
+    servicesFor,
+    type ToolLine,
+    type ToolsReport,
+    updateCommand,
+    updateId,
+    verifiedVersion,
+    verifyCommand,
+    writePostedReport,
+} from "./tools-report.ts";
+
+/** `brew outdated --json=v2` on Cortex, 2026-10-19 (a subset). */
+const OUTDATED = {
+    formulae: [
+        { name: "bitwarden-cli", installed_versions: ["2026.8.0"], current_version: "2026.9.0", pinned: false, pinned_version: null },
+        { name: "gh", installed_versions: ["2.97.0"], current_version: "2.101.0", pinned: false, pinned_version: null },
+        { name: "herdr", installed_versions: ["0.9.0"], current_version: "0.9.1", pinned: false, pinned_version: null },
+        { name: "pcre2", installed_versions: ["10.47_1"], current_version: "10.48", pinned: false, pinned_version: null },
+        { name: "pnpm", installed_versions: ["11.22.0"], current_version: "12.6.0", pinned: false, pinned_version: null },
+        { name: "ruby", installed_versions: ["4.0.6"], current_version: "4.0.7", pinned: false, pinned_version: null },
+        { name: "fnm", installed_versions: ["1.39.0"], current_version: "1.40.0", pinned: true, pinned_version: "1.39.0" },
+    ],
+    casks: [
+        { name: "codex", installed_versions: ["0.152.1"], current_version: "0.156.1", pinned: false, pinned_version: null },
+        { name: "temurin@17", installed_versions: ["17.0.20,8"], current_version: "17.0.20.1,1", pinned: false, pinned_version: null },
+    ],
+};
+
+/** `brew info --json=v2 --installed` on Cortex, reduced to the fields the report reads. */
+const INFO = {
+    formulae: [
+        { name: "astrogate", full_name: "monadeo/tap/astrogate", installed: [{ installed_on_request: true }] },
+        { name: "bitwarden-cli", full_name: "bitwarden-cli", installed: [{ installed_on_request: true }] },
+        { name: "fnm", full_name: "fnm", installed: [{ installed_on_request: true }] },
+        { name: "gh", full_name: "gh", installed: [{ installed_on_request: true }] },
+        { name: "herdr", full_name: "herdr", installed: [{ installed_on_request: true }] },
+        { name: "node", full_name: "node", installed: [{ installed_on_request: false }, { installed_on_request: true }] },
+        { name: "pcre2", full_name: "pcre2", installed: [{ installed_on_request: false }] },
+        { name: "pnpm", full_name: "pnpm", installed: [{ installed_on_request: true }] },
+        { name: "ruby", full_name: "ruby", installed: [{ installed_on_request: false }] },
+    ],
+    casks: [
+        { token: "codex", installed: "0.152.1", version: "0.156.1", auto_updates: null },
+        { token: "gcloud-cli", installed: "585.0.0", version: "586.0.0", auto_updates: true },
+        { token: "google-chrome", installed: "152.0.7977.83", version: "154.0.8037.58", auto_updates: true },
+        { token: "temurin@17", installed: "17.0.20,8", version: "17.0.20.1,1", auto_updates: null },
+    ],
+};
+
+const COLLECTED: Collected = {
+    brewInfo: INFO,
+    brewOutdated: OUTDATED,
+    piInstalled: "0.87.1",
+    piLatest: "1.3.0",
+    piAstroInstalled: "0.33.0",
+    piAstroLatest: "0.33.0",
+    installer: { node: { current: "24.22.0", previous: null }, wrappers: "0.32.0", arcaneCli: "2.16.1", trendarr: "0.6.0" },
+    arcaneServer: "2.17.0",
+    trendarrLatest: "0.6.0",
+    nodeLts: "24.22.0",
+    warnings: [],
+};
+
+describe("versions", () => {
+    it("compares dotted versions with revisions and build numbers", () => {
+        expect(compareLoose("10.48", "10.47_1")).toBeGreaterThan(0);
+        expect(compareLoose("17.0.20.1,1", "17.0.20,8")).toBeGreaterThan(0);
+        expect(compareLoose("2.101.0", "2.97.0")).toBeGreaterThan(0);
+        expect(compareLoose("1.0.0", "1.0.0")).toBe(0);
+        expect(compareLoose("17.0.20,9", "17.0.20,8")).toBeGreaterThan(0);
+        expect(majorChange("0.87.1", "1.3.0")).toBe(true);
+        expect(majorChange("2026.8.0", "2026.9.0")).toBe(false);
+    });
+
+    it("reads the newest macOS arm64 LTS, the Arcane server version, and npm's global list", () => {
+        const index = [
+            { version: "v26.12.0", lts: false, files: ["osx-arm64-tar"] },
+            { version: "v24.22.0", lts: "Krypton", files: ["osx-arm64-tar", "linux-x64"] },
+            { version: "v24.23.0", lts: "Krypton", files: ["linux-x64"] },
+            { version: "v22.21.0", lts: "Jod", files: ["osx-arm64-tar"] },
+        ];
+        expect(latestLts(index)).toBe("24.22.0");
+        expect(latestLts({})).toBeNull();
+        expect(arcaneServerVersion({ currentVersion: "v2.16.1", newestVersion: "v2.16.1" })).toBe("2.16.1");
+        expect(arcaneServerVersion({ currentVersion: "latest" })).toBeNull();
+        expect(npmGlobalVersion({ dependencies: { "@earendil-works/pi-coding-agent": { version: "0.87.1" } } }, "@earendil-works/pi-coding-agent")).toBe("0.87.1");
+    });
+});
+
+describe("report lines", () => {
+    it("lists our tools first, then requested formulae and casks; dependencies and pinned packages stay out", () => {
+        const lines = buildLines(COLLECTED);
+        expect(lines.map((l) => `${l.key} ${l.installed}->${l.latest}`)).toEqual([
+            "pi 0.87.1->1.3.0",
+            "spc:wrappers 0.32.0->0.33.0",
+            "spc:arcane-cli 2.16.1->2.17.0",
+            "brew:bitwarden-cli 2026.8.0->2026.9.0",
+            "brew:gh 2.97.0->2.101.0",
+            "brew:herdr 0.9.0->0.9.1",
+            "brew:pnpm 11.22.0->12.6.0",
+            "cask:codex 0.152.1->0.156.1",
+            "cask:temurin@17 17.0.20,8->17.0.20.1,1",
+            "cask:gcloud-cli 585.0.0->586.0.0",
+        ]);
+        expect(lines[0].major).toBe(true);
+        expect(lines.find((l) => l.key === "cask:gcloud-cli")?.action).toEqual({ kind: "cask", token: "gcloud-cli", greedy: true });
+        expect(lines.find((l) => l.key === "cask:codex")?.action).toEqual({ kind: "cask", token: "codex", greedy: false });
+        expect(lines.every((l) => l.state === "offered")).toBe(true);
+        expect(brewHasOutdated(OUTDATED)).toBe(true);
+        expect(brewHasOutdated({ formulae: [OUTDATED.formulae[6]], casks: [] })).toBe(false);
+    });
+
+    it("uses full names for tap formulae and never offers an older or equal version", () => {
+        const tap = {
+            ...COLLECTED,
+            brewInfo: { formulae: INFO.formulae, casks: [] },
+            brewOutdated: { formulae: [{ name: "astrogate", installed_versions: ["0.0.10"], current_version: "0.0.11", pinned: false }], casks: [] },
+            installer: { node: { current: "24.22.0" }, wrappers: "0.34.0", arcaneCli: "2.17.0", trendarr: "0.7.0" },
+            piLatest: "0.80.0",
+        };
+        expect(buildLines(tap).map((l) => l.key)).toEqual(["brew:monadeo/tap/astrogate"]);
+        expect(buildLines(tap)[0].action).toEqual({ kind: "brew", name: "monadeo/tap/astrogate" });
+    });
+});
+
+describe("collection", () => {
+    it("runs brew update first, then reads everything else, and turns failures into warnings", async () => {
+        const calls: string[] = [];
+        const exec: Exec = async (file, args) => {
+            calls.push(`${file.split("/").pop()} ${args.join(" ")}`);
+            if (args[0] === "update") return { code: 1, stdout: "", stderr: "Error: network down" };
+            if (args[0] === "info") return { code: 0, stdout: JSON.stringify(INFO), stderr: "" };
+            if (args[0] === "outdated") return { code: 0, stdout: JSON.stringify(OUTDATED), stderr: "" };
+            if (args[0] === "ls") return { code: 0, stdout: JSON.stringify({ dependencies: { "@earendil-works/pi-coding-agent": { version: "0.87.1" } } }), stderr: "" };
+            if (args.includes("status")) return { code: 0, stdout: JSON.stringify(COLLECTED.installer), stderr: "" };
+            if (args[0] === "view" && args[1] === "@astrofoundry/trendarr") return { code: 1, stdout: "", stderr: "npm error 404" };
+            if (args[0] === "view") return { code: 0, stdout: args[1] === "@earendil-works/pi-coding-agent" ? "1.3.0\n" : "0.33.0\n", stderr: "" };
+            return { code: 1, stdout: "", stderr: "unexpected" };
+        };
+        const dir = mkdtempSync(join(tmpdir(), "tools-pkg-"));
+        try {
+            writeFileSync(join(dir, "package.json"), JSON.stringify({ version: "0.33.0" }));
+            const fetchImpl = vi.fn(async () => new Response(JSON.stringify([{ version: "v24.22.0", lts: "Krypton", files: ["osx-arm64-tar"] }]))) as unknown as typeof fetch;
+            const c = await collectTools({ exec, fetchImpl, piAstroPackage: join(dir, "package.json"), arcaneServer: async () => "2.16.1" });
+            expect(calls[0]).toBe("brew update");
+            expect(c.warnings.join(" | ")).toMatch(/brew update failed, versions may be stale: Error: network down/);
+            expect(c.warnings.join(" | ")).toMatch(/npm view @astrofoundry\/trendarr failed/);
+            expect(c).toMatchObject({ piInstalled: "0.87.1", piLatest: "1.3.0", piAstroInstalled: "0.33.0", nodeLts: "24.22.0", arcaneServer: "2.16.1", trendarrLatest: null });
+        } finally {
+            rmSync(dir, { recursive: true, force: true });
+        }
+    });
+});
+
+function sampleReport(lines: ToolLine[], brewOutdated = true): ToolsReport {
+    return { date: "2026-10-20", checkedAt: "2026-10-20T04:00:30Z", channelId: "1549855700388151398", timeZone: "Europe/Madrid", lines, warnings: [], brewOutdated, brewAll: "offered", messages: [] };
+}
+
+describe("report layout", () => {
+    it("splits a long report into messages of at most 40 components, header first and footer last", () => {
+        const many = Array.from({ length: 15 }, (_, i) => ({ ...buildLines(COLLECTED)[3], key: `brew:pkg-${i}`, label: `pkg-${i}` }));
+        const report = sampleReport(many);
+        const pages = layoutMessages(report);
+        expect(pages.length).toBe(2);
+        expect(pages[0].head).toBe(true);
+        expect(pages[pages.length - 1].tail).toBe(true);
+        expect(pages[pages.length - 1].all).toBe(true);
+        expect(pages.flatMap((p) => p.keys)).toEqual(many.map((l) => l.key));
+        for (const p of pages) expect(countComponents(messageComponents(report, p))).toBeLessThanOrEqual(40);
+        const first = messageComponents(report, pages[0]);
+        expect(first[0].content).toMatch(/^\*\*Cortex Tools Report:\*\* 15 updates \(checked 06:00 CEST\)\.$/);
+    });
+
+    it("says everything is up to date without buttons", () => {
+        const report = sampleReport([], false);
+        const pages = layoutMessages(report);
+        expect(pages).toEqual([{ keys: [], head: true, all: false, tail: false }]);
+        expect(messageComponents(report, pages[0])).toEqual([{ type: 10, content: "**Cortex Tools Report:** everything is up to date (checked 06:00 CEST)." }]);
+    });
+
+    it("shows the review, a major change, and each button state", () => {
+        const [pi] = buildLines(COLLECTED);
+        pi.review = { verdict: "breaking", reason: "Removes the `--tools` flag in favor of `--allow`" };
+        expect(lineText(pi)).toBe("**Pi** 0.87.1 → 1.3.0 · major version\n-# 🔴 breaking: Removes the \\`--tools\\` flag in favor of \\`--allow\\`");
+        const report = sampleReport([pi]);
+        const page = layoutMessages(report)[0];
+        const button = () => messageComponents(report, page)[1].accessory;
+        expect(button()).toMatchObject({ label: "Update", style: 1, custom_id: "tools:up:pi|1.3.0" });
+        pi.state = "running";
+        expect(button()).toMatchObject({ label: "Updating…", disabled: true });
+        pi.state = "failed";
+        expect(button()).toMatchObject({ label: "Retry", style: 4 });
+        expect(button()?.disabled).toBeUndefined();
+        pi.state = "updated";
+        expect(button()).toMatchObject({ label: "Updated", style: 3, disabled: true });
+        expect(messageComponents(report, page)[2].accessory).toMatchObject({ label: "Upgrade everything", custom_id: "tools:all:2026-10-20" });
+    });
+});
+
+describe("buttons and commands", () => {
+    it("round-trips button ids and refuses anything else", () => {
+        const lines = buildLines(COLLECTED);
+        for (const l of lines) expect(parseToolsButton(updateId(l))).toEqual({ kind: "update", key: l.key, version: l.latest });
+        expect(parseToolsButton(allId("2026-10-20"))).toEqual({ kind: "all", date: "2026-10-20" });
+        expect(parseToolsButton("tools:restart:herdr")).toEqual({ kind: "restart", service: "herdr" });
+        expect(parseToolsButton("tools:up:brew:gh;rm -rf|2.101.0")).toBeNull();
+        expect(parseToolsButton("tools:up:spc:everything|1.0.0")).toBeNull();
+        expect(parseToolsButton("tools:up:pi|1.3.0 && x")).toBeNull();
+        expect(parseToolsButton("tools:restart:sshd")).toBeNull();
+    });
+
+    it("runs one fixed command per kind, reads the version back, and knows what to roll back and restart", () => {
+        expect(updateCommand({ kind: "brew", name: "monadeo/tap/astrogate" }, "0.0.11")).toEqual({ file: "/opt/homebrew/bin/brew", args: ["upgrade", "monadeo/tap/astrogate"] });
+        expect(updateCommand({ kind: "cask", token: "gcloud-cli", greedy: true }, "586.0.0").args).toEqual(["upgrade", "--cask", "--greedy", "gcloud-cli"]);
+        expect(updateCommand({ kind: "cask", token: "codex", greedy: false }, "0.156.1").args).toEqual(["upgrade", "--cask", "codex"]);
+        expect(updateCommand({ kind: "pi" }, "1.3.0")).toEqual({ file: "/opt/homebrew/bin/pi", args: ["update", "--self"] });
+        expect(updateCommand({ kind: "pi-astro" }, "0.33.0").args).toEqual(["update", "npm:@astrofoundry/pi-astro"]);
+        expect(updateCommand({ kind: "installer", component: "arcane-cli" }, "2.17.0")).toEqual({ file: "/usr/bin/sudo", args: ["-n", "/usr/local/sbin/specialist-install", "arcane-cli", "2.17.0"] });
+        expect(rollbackCommand({ kind: "pi" }, "0.87.1")?.args).toEqual(["install", "-g", "@earendil-works/pi-coding-agent@0.87.1"]);
+        expect(rollbackCommand({ kind: "brew", name: "gh" }, "2.97.0")).toBeNull();
+        expect(verifyCommand({ kind: "brew", name: "gh" })?.args).toEqual(["list", "--versions", "gh"]);
+        expect(verifyCommand({ kind: "pi-astro" })).toBeNull();
+        expect(verifiedVersion({ kind: "brew", name: "node" }, "node 26.7.0 26.9.0\n", "26.9.0")).toBe(true);
+        expect(verifiedVersion({ kind: "brew", name: "gh" }, "gh 2.97.0\n", "2.101.0")).toBe(false);
+        expect(verifiedVersion({ kind: "installer", component: "node" }, JSON.stringify({ node: { current: "24.23.0" } }), "24.23.0")).toBe(true);
+        expect(verifiedVersion({ kind: "pi" }, "not json", "1.3.0")).toBe(false);
+        expect(servicesFor({ kind: "pi" })).toEqual(["bridge"]);
+        expect(servicesFor({ kind: "brew", name: "node" })).toEqual(["astrogate", "bridge"]);
+        expect(servicesFor({ kind: "brew", name: "herdr" })).toEqual(["herdr"]);
+        expect(servicesFor({ kind: "installer", component: "node" })).toEqual([]);
+        expect(servicesFor("brew-all")).toEqual(["herdr", "astrogate", "bridge"]);
+    });
+});
+
+describe("release-notes review", () => {
+    const release = (tag: string, body: string, prerelease = false) => ({ tag_name: tag, name: tag, body, published_at: "2026-10-15T00:00:00Z", html_url: `https://github.com/x/releases/${tag}`, draft: false, prerelease });
+
+    it("reads only the tool's own releases in a shared repository, between the two versions", async () => {
+        const fetchImpl = vi.fn(async () => new Response(JSON.stringify([release("cli-v2026.9.0", "bw: new list flag"), release("desktop-v2026.9.0", "desktop only"), release("cli-v2026.8.0", "old")]))) as unknown as typeof fetch;
+        const line = buildLines(COLLECTED).find((l) => l.key === "brew:bitwarden-cli") as ToolLine;
+        const notes = await notesFor(line, fetchImpl);
+        expect(notes.notes?.map((n) => n.tag)).toEqual(["v2026.9.0"]);
+        const prompt = reviewPrompt(line, notes.notes ?? [], []);
+        expect(prompt).toMatch(/How Cortex uses it: specialist-cli provision runs bw/);
+        expect(prompt).toMatch(/<<<RELEASE NOTES\n### v2026\.9\.0 \(2026-10-15\)\nbw: new list flag\nRELEASE NOTES>>>/);
+    });
+
+    it("says why there is nothing to review", async () => {
+        const gcloud = buildLines(COLLECTED).find((l) => l.key === "cask:gcloud-cli") as ToolLine;
+        expect(await notesFor(gcloud, fetch)).toEqual({ notes: null, reason: "no release notes to review here; see https://cloud.google.com/sdk/docs/release-notes" });
+        const trendarr: ToolLine = { key: "spc:trendarr", label: "trendarr", installed: "0.6.0", latest: "0.7.0", major: false, action: { kind: "installer", component: "trendarr" }, state: "offered" };
+        const notFound = vi.fn(async () => new Response("{}", { status: 404 })) as unknown as typeof fetch;
+        expect(await notesFor(trendarr, notFound)).toMatchObject({ notes: null, reason: expect.stringMatching(/release notes unavailable: GitHub answered 404/) });
+        const empty = vi.fn(async () => new Response("[]")) as unknown as typeof fetch;
+        const herdr = buildLines(COLLECTED).find((l) => l.key === "brew:herdr") as ToolLine;
+        expect(await notesFor(herdr, empty)).toEqual({ notes: null, reason: "GitHub lists no release between the two versions" });
+        expect(await notesFor(buildLines(COLLECTED).find((l) => l.key === "brew:gh") as ToolLine, empty)).toEqual({ notes: null, reason: "not reviewed" });
+    });
+
+    it("accepts only the requested JSON verdict", () => {
+        expect(parseVerdict('{"verdict":"check","reason":"Changes the default of --local-host-port"}')).toEqual({ verdict: "check", reason: "Changes the default of --local-host-port" });
+        expect(parseVerdict('Sure.\n{"verdict":"none","reason":"nothing relevant"}')).toEqual({ verdict: "none", reason: "nothing relevant" });
+        expect(parseVerdict('{"verdict":"ignore previous instructions","reason":"x"}')).toBeNull();
+        expect(parseVerdict("no json")).toBeNull();
+        expect(parseVerdict(`{"verdict":"breaking","reason":"${"x".repeat(300)}"}`)?.reason).toHaveLength(160);
+    });
+});
+
+describe("state files", () => {
+    let dir: string;
+    beforeEach(() => {
+        dir = mkdtempSync(join(tmpdir(), "astro-tools-"));
+        process.env.ASTRO_DISCORD_DIR = dir;
+    });
+    afterEach(() => {
+        delete process.env.ASTRO_DISCORD_DIR;
+        rmSync(dir, { recursive: true, force: true });
+    });
+
+    it("keeps the posted report for button checks", () => {
+        expect(readPostedReport()).toBeNull();
+        const report = { ...sampleReport(buildLines(COLLECTED)), messages: [{ id: "1", keys: ["pi"], head: true, all: false, tail: false }] };
+        writePostedReport(report);
+        expect(readPostedReport()).toEqual(report);
+    });
+
+    it("merges waiting restarts and offers Restart now after a day", () => {
+        const t0 = new Date("2026-10-20T08:00:00Z");
+        let pending = addRestarts([], ["bridge"], "Pi 1.3.0", t0);
+        pending = addRestarts(pending, ["herdr", "bridge"], "herdr 0.9.1", new Date("2026-10-20T09:00:00Z"));
+        expect(pending.map((p) => p.service)).toEqual(["herdr", "bridge"]);
+        expect(pending.find((p) => p.service === "bridge")).toMatchObject({ since: t0.toISOString(), reasons: ["Pi 1.3.0", "herdr 0.9.1"] });
+        expect(needsPrompt(pending[1], new Date(t0.getTime() + RESTART_WAIT_MS - 1))).toBe(false);
+        expect(needsPrompt(pending[1], new Date(t0.getTime() + RESTART_WAIT_MS))).toBe(true);
+        expect(needsPrompt({ ...pending[1], prompt: { channelId: "1", messageId: "2" } }, new Date(t0.getTime() + 2 * RESTART_WAIT_MS))).toBe(false);
+        writeRestarts(pending);
+        expect(readRestarts()).toEqual(pending);
+        writeRestarts([]);
+        expect(readRestarts()).toEqual([]);
+        expect(SERVICE_ORDER[SERVICE_ORDER.length - 1]).toBe("bridge");
+    });
+});
+
+describe("service activity", () => {
+    it("counts every herdr agent and every Astrogate session as running", () => {
+        expect(herdrActivity(0, '{"id":"cli:agent:list","result":{"agents":[],"type":"agent_list"}}', "")).toEqual({ idle: true, running: [] });
+        expect(herdrActivity(0, '{"result":{"agents":[{"name":"worker-1","state":"working"},{"pane_id":"w1:p2","state":"idle"}]}}', "")).toEqual({ idle: false, running: ["worker-1 (working)", "w1:p2 (idle)"] });
+        expect(herdrActivity(1, "", "server not running").idle).toBe(false);
+        expect(astrogateActivity(0, "No running sessions.\n", "")).toEqual({ idle: true, running: [] });
+        expect(astrogateActivity(0, "worker   monadeo/16db.org#1 attempt 1 pane w1:p1\n", "")).toEqual({ idle: false, running: ["worker   monadeo/16db.org#1 attempt 1 pane w1:p1"] });
+    });
+
+    it("restarts each service through its manager", () => {
+        expect(restartCommand("herdr", 501)).toEqual({ file: "/opt/homebrew/bin/brew", args: ["services", "restart", "herdr"] });
+        expect(restartCommand("astrogate", 501).args).toEqual(["kickstart", "-k", "gui/501/com.monadeo.astrogate"]);
+        expect(restartCommand("bridge", 501).args).toEqual(["kickstart", "-k", "gui/501/com.astrofoundry.astro-discord"]);
+    });
+});