cursedbelt-server 1.0.0

package/src/server/incidents/incidents.spec.ts

@@ -0,0 +1,463 @@
+/**
+ * The dedupe guarantee, proved rather than asserted.
+ *
+ * The owner's requirement was one sentence — *"it needs to avoid sending me the
+ * same problem over and over in duplicated notifications if it's polling for
+ * problems"* — and it is the requirement that decides whether the feature is
+ * used or muted. So the first test here is literally the poller, run twice
+ * against an unchanged failure, counting messages.
+ *
+ * The rest are the ways a naive version lies: a crashed detector announcing that
+ * an outage is over, a resolve for something the owner was never told about, a
+ * private file name reaching a text message, and a broken channel being told
+ * about itself down itself.
+ */
+import { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { ChannelMessage, ChannelResult, IncidentChannel } from "./channels";
+import { createTextChannel } from "./channels";
+import { type IncidentCheck, runIncidentSweep } from "./checks";
+import { createIncidentNotifier, UNDELIVERED_RETRY_MS } from "./notifier";
+import { createIncidentReporter } from "./reporter";
+import { createIncidentStore, type IncidentStore } from "./store";
+import type { IncidentReport } from "./types";
+
+const stuckIngest = (failed = 42): IncidentReport => ({
+	source: "station",
+	kind: "ingest-run-all-failed",
+	subject: "collections",
+	severity: "blocking",
+	title: "collections: every queued upload is failing",
+	whatBroke: "The scheduled ingest ran and every one of its items failed.",
+	whatItBlocks: "Nothing new reaches the collections app, and the queue keeps growing.",
+	whatToDo: "cd ~/code/local/binary-server && bun run storage-drift",
+	facts: { failed, pending: failed },
+});
+
+/** A channel that records what it was asked to send, and always succeeds. */
+function spyChannel(key = "text"): IncidentChannel & { sent: ChannelMessage[] } {
+	const sent: ChannelMessage[] = [];
+	return {
+		key,
+		label: `spy:${key}`,
+		sent,
+		async send(message): Promise<ChannelResult> {
+			sent.push(message);
+			return { channel: key, outcome: "delivered", detail: "spy" };
+		},
+	};
+}
+
+const checkOf = (run: IncidentCheck["run"]): IncidentCheck => ({
+	key: "ingest",
+	source: "station",
+	kinds: ["ingest-run-all-failed"],
+	label: "Ingest runs",
+	run,
+});
+
+describe("incident dedupe", () => {
+	let db: Database;
+	let store: IncidentStore;
+
+	beforeEach(() => {
+		db = new Database(":memory:");
+		store = createIncidentStore(db);
+	});
+
+	test("a poller that sees the same failure twice notifies ONCE", async () => {
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		const check = checkOf(() => [stuckIngest()]);
+
+		for (let i = 0; i < 2; i++) {
+			const sweep = await runIncidentSweep(store, [check]);
+			await notifier.announce(sweep.transitions);
+		}
+
+		expect(channel.sent).toHaveLength(1);
+		expect(channel.sent[0]?.subject).toContain("collections");
+		const incident = store.list({ state: "active" })[0];
+		expect(incident?.seenCount).toBe(2);
+		expect(incident?.episodes).toBe(1);
+	});
+
+	test("ten more sweeps still notify nothing, even as the numbers move", async () => {
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		let failed = 42;
+		const check = checkOf(() => [stuckIngest(failed)]);
+
+		for (let i = 0; i < 12; i++) {
+			failed += 1;
+			const sweep = await runIncidentSweep(store, [check]);
+			await notifier.announce(sweep.transitions);
+		}
+
+		expect(channel.sent).toHaveLength(1);
+		// The refreshed facts are what the console shows, so they must move.
+		expect(store.list({ state: "active" })[0]?.facts?.failed).toBe(54);
+	});
+
+	test("a fix notifies once more, and a relapse is a new episode", async () => {
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		let broken = true;
+		const check = checkOf(() => (broken ? [stuckIngest()] : []));
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		broken = false;
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		broken = true;
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+
+		expect(channel.sent.map((m) => m.subject)).toEqual([
+			"[BLOCKED] collections: every queued upload is failing",
+			"[cleared] collections: every queued upload is failing",
+			"[BLOCKED] collections: every queued upload is failing",
+		]);
+		expect(store.list({ state: "active" })[0]?.episodes).toBe(2);
+	});
+
+	test("a warning that becomes blocking is announced again — the channels changed", async () => {
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		let severity: "warning" | "blocking" = "warning";
+		const check = checkOf(() => [{ ...stuckIngest(), severity }]);
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		severity = "blocking";
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+
+		expect(channel.sent.map((m) => m.severity)).toEqual(["warning", "blocking"]);
+	});
+});
+
+describe("a broken detector never says everything is fine", () => {
+	let store: IncidentStore;
+
+	beforeEach(() => {
+		store = createIncidentStore(new Database(":memory:"));
+	});
+
+	test("a check that THROWS leaves its open incidents open, and sends nothing", async () => {
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		let mode: "broken" | "throw" = "broken";
+		const check = checkOf(() => {
+			if (mode === "throw") throw new Error("ENOENT: the queue directory is gone");
+			return [stuckIngest()];
+		});
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		mode = "throw";
+		const second = await runIncidentSweep(store, [check]);
+		await notifier.announce(second.transitions);
+
+		expect(second.outcomes[0]?.status).toBe("failed");
+		expect(second.outcomes[0]?.error).toContain("ENOENT");
+		expect(second.transitions.resolved).toHaveLength(0);
+		expect(store.list({ state: "active" })).toHaveLength(1);
+		// One message, from the first sweep. No "cleared".
+		expect(channel.sent).toHaveLength(1);
+	});
+
+	test("a check clears only the kinds it DECLARES", async () => {
+		// A check that opened an incident of a kind it no longer declares cannot
+		// resolve it — better a stale red the console shows than a false all-clear.
+		store.reconcile("ingest", [stuckIngest()], {
+			namespaces: ["station:ingest-run-all-failed:"],
+		});
+		const narrowed: IncidentCheck = { ...checkOf(() => []), kinds: ["some-other-kind"] };
+		const sweep = await runIncidentSweep(store, [narrowed]);
+		expect(sweep.transitions.resolved).toHaveLength(0);
+		expect(store.list({ state: "active" })).toHaveLength(1);
+	});
+
+	test("one check cannot resolve another check's incidents", async () => {
+		store.reconcile("ingest", [stuckIngest()], {
+			namespaces: ["station:ingest-run-all-failed:"],
+		});
+		const impostor: IncidentCheck = {
+			key: "disk",
+			source: "station",
+			kinds: ["ingest-run-all-failed"],
+			label: "Disk",
+			run: () => [],
+		};
+		await runIncidentSweep(store, [impostor]);
+		expect(store.list({ state: "active" })).toHaveLength(1);
+	});
+});
+
+describe("what a message may not contain or travel down", () => {
+	let store: IncidentStore;
+
+	beforeEach(() => {
+		store = createIncidentStore(new Database(":memory:"));
+	});
+
+	test("a string in `facts` is refused at the write — it is how a file name reaches a phone", () => {
+		expect(() =>
+			store.reconcile("ingest", [
+				{
+					...stuckIngest(),
+					// biome-ignore lint/suspicious/noExplicitAny: the point of the test is the wrong type
+					facts: { failed: 42, firstFile: "Mom's 60th birthday.mov" as any },
+				},
+			]),
+		).toThrow(/facts take numbers/);
+	});
+
+	test("an incident about a dead channel is not sent down that channel", async () => {
+		const text = spyChannel("text");
+		const notifier = createIncidentNotifier({ store, channels: [text] });
+		const t = store.reconcile("channel-health", [
+			{
+				source: "station",
+				kind: "notification-channel-failing",
+				subject: "text",
+				severity: "blocking",
+				title: "The text-message channel is not delivering",
+				whatBroke: "The last blocking alert could not be proven to have left this Mac.",
+				whatItBlocks: "You would not be texted about the next outage.",
+				whatToDo: "Open the console → Incidents → Send a test text.",
+			},
+		]);
+		await notifier.announce(t);
+		expect(text.sent).toHaveLength(0);
+	});
+
+	test("a resolve for an incident the owner was never told about is not sent", async () => {
+		// No channels on the first pass: the open is recorded but never announced.
+		const silent = createIncidentNotifier({ store, channels: [] });
+		const check = checkOf(() => [stuckIngest()]);
+		await silent.announce((await runIncidentSweep(store, [check])).transitions);
+
+		const channel = spyChannel();
+		const loud = createIncidentNotifier({ store, channels: [channel] });
+		const cleared = checkOf(() => []);
+		await loud.announce((await runIncidentSweep(store, [cleared])).transitions);
+
+		expect(channel.sent).toHaveLength(0);
+	});
+});
+
+describe("the text channel deals in evidence", () => {
+	const message: ChannelMessage = {
+		severity: "blocking",
+		subject: "[BLOCKED] test",
+		text: "body",
+	};
+
+	test("osascript exiting 0 is NOT delivery — an unprovable send is `unproven`", async () => {
+		const channel = createTextChannel({
+			handle: "+15550000000",
+			send: async () => ({ ok: true, detail: "accepted" }),
+			proveSent: async () => null, // chat.db unreadable
+		});
+		const result = await channel.send(message);
+		expect(result.outcome).toBe("unproven");
+		expect(result.detail).toContain("Full Disk Access");
+	});
+
+	test("a sent row in chat.db is delivery", async () => {
+		const channel = createTextChannel({
+			handle: "+15550000000",
+			send: async () => ({ ok: true, detail: "accepted" }),
+			proveSent: async () => true,
+		});
+		expect((await channel.send(message)).outcome).toBe("delivered");
+	});
+
+	test("no proof row inside the window is `unproven`, not `delivered`", async () => {
+		const channel = createTextChannel({
+			handle: "+15550000000",
+			send: async () => ({ ok: true, detail: "accepted" }),
+			proveSent: async () => false,
+			proofTimeoutMs: 20,
+		});
+		const result = await channel.send(message);
+		expect(result.outcome).toBe("unproven");
+		expect(result.detail).toContain("no sent row appeared");
+	});
+
+	test("a warning never reaches the phone", async () => {
+		const channel = createTextChannel({
+			handle: "+15550000000",
+			send: async () => {
+				throw new Error("must not be called");
+			},
+		});
+		expect((await channel.send({ ...message, severity: "warning" })).outcome).toBe("skipped");
+	});
+});
+
+describe("acknowledgement", () => {
+	test("an acknowledged incident stays listed, stays deduped, and still clears", async () => {
+		const store = createIncidentStore(new Database(":memory:"));
+		const channel = spyChannel();
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		let broken = true;
+		const check = checkOf(() => (broken ? [stuckIngest()] : []));
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		const fp = store.list({ state: "active" })[0]?.fingerprint ?? "";
+		expect(store.acknowledge(fp)).toBe(true);
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(channel.sent).toHaveLength(1);
+		expect(store.get(fp)?.state).toBe("acknowledged");
+
+		broken = false;
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(store.get(fp)?.state).toBe("resolved");
+		expect(channel.sent).toHaveLength(2);
+	});
+});
+
+describe("a remote reporter", () => {
+	test("posts the complete set every beat, so the console can CLEAR as well as open", async () => {
+		const posted: Array<Record<string, unknown>> = [];
+		let broken = true;
+		const reporter = createIncidentReporter({
+			url: "http://console.invalid/report",
+			token: "t",
+			source: "binary-server",
+			checkKey: "bs:self",
+			kinds: ["disk-below-reserve"],
+			collect: () =>
+				broken
+					? [
+							{
+								source: "binary-server",
+								kind: "disk-below-reserve",
+								subject: "binary-server",
+								severity: "blocking" as const,
+								title: "t",
+								whatBroke: "b",
+								whatItBlocks: "c",
+								whatToDo: "d",
+							},
+						]
+					: [],
+			fetchImpl: (async (_url: string, init: RequestInit) => {
+				posted.push(JSON.parse(String(init.body)) as Record<string, unknown>);
+				return new Response("{}", { status: 200 });
+			}) as unknown as typeof fetch,
+		});
+
+		expect(await reporter.beat()).toBe(true);
+		broken = false;
+		expect(await reporter.beat()).toBe(true);
+
+		// The healthy beat still fires and still declares its kinds — that empty
+		// `reports` with a non-empty `kinds` is the ONLY thing that can resolve the
+		// incident the first beat opened.
+		expect((posted[1]?.reports as unknown[])).toHaveLength(0);
+		expect(posted[1]?.kinds).toEqual(["disk-below-reserve"]);
+	});
+
+	test("an unreachable console is false, never a throw — alerting must not break the service", async () => {
+		const reporter = createIncidentReporter({
+			url: "http://console.invalid/report",
+			token: "t",
+			source: "binary-server",
+			checkKey: "bs:self",
+			kinds: ["disk-below-reserve"],
+			collect: () => [],
+			log: () => {},
+			fetchImpl: (async () => {
+				throw new Error("ECONNREFUSED");
+			}) as unknown as typeof fetch,
+		});
+		expect(await reporter.beat()).toBe(false);
+	});
+});
+
+describe("the text channel names the macOS decision, not the error code", () => {
+	test("a -1712 TIMEOUT from a daemon is reported as the consent problem it is", async () => {
+		// The real symptom, measured 2026-08-21: the console's launchd daemon got
+		// `AppleEvent timed out. (-1712)` — not a refusal — while TCC.db held a
+		// fresh DENY for it. An agent reading "-1712" learns nothing; the message
+		// has to name the toggle.
+		const channel = createTextChannel({
+			handle: "+15550000000",
+			send: async () => ({
+				ok: false,
+				detail:
+					"macOS has Automation access to Messages DENIED for this console's daemon. Turn it back on in System Settings ▸ Privacy & Security ▸ Automation (the entry is 'bun'), then press Send a test.",
+			}),
+		});
+		const result = await channel.send({
+			severity: "blocking",
+			subject: "s",
+			text: "t",
+		});
+		expect(result.outcome).toBe("failed");
+		expect(result.detail).toContain("Privacy & Security");
+		expect(result.detail).not.toContain("-1712");
+	});
+});
+
+describe("an alert nobody could be told about is retried", () => {
+	test("a blocking incident whose channels ALL failed tries again an hour later — once", async () => {
+		const store = createIncidentStore(new Database(":memory:"));
+		let deliver = false;
+		const sent: string[] = [];
+		const flaky: IncidentChannel = {
+			key: "text",
+			label: "flaky",
+			async send(message) {
+				sent.push(message.subject);
+				return deliver
+					? { channel: "text", outcome: "delivered", detail: "ok" }
+					: { channel: "text", outcome: "failed", detail: "no" };
+			},
+		};
+		const notifier = createIncidentNotifier({ store, channels: [flaky] });
+		const check = checkOf(() => [stuckIngest()]);
+
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(sent).toHaveLength(1);
+
+		// Within the hour: nothing. This is still the dedupe promise.
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(sent).toHaveLength(1);
+
+		// Age the failed attempt past the window.
+		const fp = store.list({ state: "active" })[0]?.fingerprint ?? "";
+		store.markNotified([fp], "text=failed", Date.now() - UNDELIVERED_RETRY_MS - 1000);
+
+		deliver = true;
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(sent).toHaveLength(2);
+
+		// It landed, so it is never sent again however long it stays open.
+		store.markNotified([fp], "text=delivered", Date.now() - UNDELIVERED_RETRY_MS - 1000);
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(sent).toHaveLength(2);
+	});
+
+	test("a WARNING that failed is not retried — it was never entitled to a channel", async () => {
+		const store = createIncidentStore(new Database(":memory:"));
+		const sent: string[] = [];
+		const channel: IncidentChannel = {
+			key: "in-app",
+			label: "bell",
+			async send(m) {
+				sent.push(m.subject);
+				return { channel: "in-app", outcome: "failed", detail: "no" };
+			},
+		};
+		const notifier = createIncidentNotifier({ store, channels: [channel] });
+		const check = checkOf(() => [{ ...stuckIngest(), severity: "warning" as const }]);
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		const fp = store.list({ state: "active" })[0]?.fingerprint ?? "";
+		store.markNotified([fp], "in-app=failed", Date.now() - UNDELIVERED_RETRY_MS - 1000);
+		await notifier.announce((await runIncidentSweep(store, [check])).transitions);
+		expect(sent).toHaveLength(1);
+	});
+});

package/src/server/incidents/index.ts

@@ -0,0 +1,96 @@
+/**
+ * `cursedbelt-server/incidents` — the fleet's ONE owner-alert primitive: a
+ * condition that is true for a while, told to the owner exactly once, and told
+ * to him again when it clears.
+ *
+ * ── Why it exists (the owner, 2026-08-13) ───────────────────────────────────
+ * *"I found out from an agent my collection uploads were stuck … there are
+ * probably all kinds of possible problems I miss over time, such as every orch
+ * task failing to deploy and live sites falling over 10 commits behind."*
+ * The incident behind it: 42 videos / 35 GB sat in the collections dropzone and
+ * every scheduled ingest failed all 42 with EPIPE against binary-server, while
+ * binary-server logged that it was under its 12 GB disk reserve — and the
+ * dropzone deletes originals once they reach the catalog. Nothing told him. Two
+ * separate deterministic checks would each have caught it on the first run.
+ *
+ * ── Why it is HERE and not in `satellite-kit` ───────────────────────────────
+ * The queued task suggested satellite-kit ("beside the metrics buffer"), and
+ * that would have been wrong for one measurable reason: **binary-server is one
+ * of the three apps the owner named, it is a different repo, and it depends on
+ * `cursedbelt` and `cwip` — not on satellite-kit.** Putting the engine in the
+ * kit would have meant bs either growing its own copy or growing a dependency on
+ * the satellites' internal kit, and the first of those is the drift this whole
+ * queue exists to end. The fleet-shaped DETECTORS (the deploy ledger, launchd,
+ * backups) are satellite-shaped and do live in the kit; the engine is here.
+ *
+ * ── The four pieces ─────────────────────────────────────────────────────────
+ *  - {@link createIncidentStore} — one row per condition, and `reconcile`, which
+ *    is the entire dedupe guarantee. Nothing else in the system decides whether
+ *    something is new.
+ *  - {@link runIncidentSweep} — runs checks; a check that THROWS resolves
+ *    nothing, so a broken detector can never announce that an outage is over.
+ *  - channels — in-app (the fleet's existing notification centre), email, and a
+ *    text message from this Mac that reads `chat.db` back to prove it left.
+ *  - {@link createIncidentNotifier} — composes the three-sentence message and
+ *    sends it on OPEN, on ESCALATE and on RESOLVE. Never on an observation.
+ *
+ * ```ts
+ * const store = createIncidentStore(db);
+ * const notifier = createIncidentNotifier({ store, channels });
+ * const result = await runIncidentSweep(store, checks);
+ * await notifier.announce(result.transitions);   // usually sends nothing
+ * ```
+ */
+export {
+	type ChannelMessage,
+	type ChannelOutcome,
+	type ChannelResult,
+	createEmailChannel,
+	createInAppChannel,
+	createRelayEmailChannel,
+	createTextChannel,
+	type EmailChannelOptions,
+	type IncidentChannel,
+	type SendEmail,
+	type TextChannelOptions,
+} from "./channels";
+export {
+	type CheckOutcome,
+	type IncidentCheck,
+	runIncidentSweep,
+	type SweepResult,
+} from "./checks";
+export { INCIDENT_MIGRATIONS, INCIDENTS_TABLE } from "./migrations";
+export {
+	type AnnounceResult,
+	composeOpened,
+	composeResolved,
+	type CreateNotifierOptions,
+	createIncidentNotifier,
+	type IncidentNotifier,
+} from "./notifier";
+export {
+	createIncidentReporter,
+	type IncidentReporter,
+	type IncidentReporterOptions,
+} from "./reporter";
+export {
+	type IncidentRoutesOptions,
+	mountIncidentMachineRoutes,
+	mountIncidentOwnerRoutes,
+} from "./routes";
+export {
+	assertNoContent,
+	createIncidentStore,
+	type IncidentStore,
+	type ReconcileOptions,
+} from "./store";
+export {
+	fingerprint,
+	type Incident,
+	type IncidentFact,
+	type IncidentReport,
+	type IncidentSeverity,
+	type IncidentState,
+	type IncidentTransitions,
+} from "./types";

package/src/server/incidents/migrations.ts

@@ -0,0 +1,66 @@
+import type { Database } from "bun:sqlite";
+import type { Migration } from "../migration/types";
+
+/** The one table this primitive owns. */
+export const INCIDENTS_TABLE = "incidents";
+
+/**
+ * ONE row per CONDITION, keyed by its fingerprint — not one row per observation.
+ *
+ * That is the whole dedupe design expressed as a schema: a poller that notices
+ * the same broken thing 288 times a day cannot produce 288 rows, because there
+ * is nowhere to put them. `seen_count` and `last_seen` absorb the repetition,
+ * and the notification columns record that the owner was told ONCE.
+ *
+ * 🔴 **Never retention-managed.** Every other telemetry table in this package
+ * is capped or aged out; this one is not, and must not be declared as a
+ * retention target. An incident is the record of something having gone wrong on
+ * a fleet whose owner's stated problem is *"I missed this for a long time"* —
+ * the row that answers "has this happened before?" six months later is the
+ * expensive one to have thrown away. The table is bounded by reality instead:
+ * a fingerprint is stable, so a recurring problem re-uses its row forever.
+ */
+export const INCIDENT_MIGRATIONS: readonly Migration[] = [
+	{
+		name: "0001_incidents",
+		up(db: Database): void {
+			db.run(`
+				CREATE TABLE IF NOT EXISTS ${INCIDENTS_TABLE} (
+					fingerprint          TEXT PRIMARY KEY,
+					source               TEXT NOT NULL,
+					check_key            TEXT NOT NULL,
+					kind                 TEXT NOT NULL,
+					subject              TEXT NOT NULL,
+					severity             TEXT NOT NULL
+					                     CHECK (severity IN ('blocking', 'warning')),
+					state                TEXT NOT NULL
+					                     CHECK (state IN ('open', 'acknowledged', 'resolved')),
+					title                TEXT NOT NULL,
+					what_broke           TEXT NOT NULL,
+					what_it_blocks       TEXT NOT NULL,
+					what_to_do           TEXT NOT NULL,
+					facts_json           TEXT,
+					first_seen           INTEGER NOT NULL,
+					last_seen            INTEGER NOT NULL,
+					seen_count           INTEGER NOT NULL DEFAULT 1,
+					episodes             INTEGER NOT NULL DEFAULT 1,
+					acknowledged_at      INTEGER,
+					resolved_at          INTEGER,
+					notified_at          INTEGER,
+					notify_result        TEXT,
+					resolved_notified_at INTEGER
+				)
+			`);
+			// The read every screen starts from: what is wrong right now.
+			db.run(
+				`CREATE INDEX IF NOT EXISTS idx_incidents_state
+					ON ${INCIDENTS_TABLE} (state, severity, last_seen DESC)`,
+			);
+			// The read `reconcile` does on every sweep, for every check.
+			db.run(
+				`CREATE INDEX IF NOT EXISTS idx_incidents_check
+					ON ${INCIDENTS_TABLE} (check_key, state)`,
+			);
+		},
+	},
+];