heyio 0.42.0 → 1.0.0

package/dist/store/instances.test.js

@@ -1,310 +0,0 @@
-/**
- * Tests for src/store/instances.ts — squad instances store.
- *
- * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
- * fresh tmp file so these tests never touch ~/.io/io.db.
- */
-import { before, after, beforeEach, describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { setDbPathForTests, closeDb, getDb } from "./db.js";
-import { createInstance, getInstance, listInstances, updateInstanceStatus, logInstanceDecision, getInstanceDecisions, mergeInstanceDecisions, deleteInstance, buildContextSnapshot, reconcileInstances, MAX_CONCURRENT_INSTANCES, } from "./instances.js";
-import { logDecision, getDecisions } from "./squads.js";
-// ── DB isolation ─────────────────────────────────────────────────────────────
-let tmpDir;
-before(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "io-instances-test-"));
-    setDbPathForTests(join(tmpDir, "io.db"));
-});
-after(() => {
-    closeDb();
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-beforeEach(() => {
-    const db = getDb();
-    db.prepare("DELETE FROM instance_decisions").run();
-    db.prepare("DELETE FROM squad_instances").run();
-    db.prepare("DELETE FROM squad_decisions").run();
-    db.prepare("DELETE FROM squads").run();
-    db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("test-squad", "Test Squad", "/tmp/test");
-});
-// ── helpers ───────────────────────────────────────────────────────────────────
-function makeInstance(id, slug = "test-squad", status) {
-    const inst = createInstance({
-        id,
-        masterSquadSlug: slug,
-        issueRef: `#${id}`,
-        worktreePath: `/tmp/nonexistent-worktree-${id}`,
-        branchName: `${slug}/instance/${id}`,
-    });
-    if (status && status !== "pending") {
-        updateInstanceStatus(id, status);
-    }
-    return inst;
-}
-// ── createInstance ────────────────────────────────────────────────────────────
-describe("createInstance", () => {
-    it("creates and returns an instance with correct fields", () => {
-        const inst = createInstance({
-            id: "inst-1",
-            masterSquadSlug: "test-squad",
-            issueRef: "#42",
-            worktreePath: "/tmp/wt/inst-1",
-            branchName: "test-squad/instance/inst-1",
-            contextSnapshot: JSON.stringify([{ decision: "use TypeScript" }]),
-        });
-        assert.equal(inst.id, "inst-1");
-        assert.equal(inst.master_squad_slug, "test-squad");
-        assert.equal(inst.issue_ref, "#42");
-        assert.equal(inst.worktree_path, "/tmp/wt/inst-1");
-        assert.equal(inst.branch_name, "test-squad/instance/inst-1");
-        assert.equal(inst.status, "pending");
-        assert.ok(inst.context_snapshot?.includes("use TypeScript"));
-        assert.equal(inst.completed_at, null);
-        assert.ok(inst.created_at);
-    });
-    it("throws when max concurrent instances are exceeded", () => {
-        // Create MAX_CONCURRENT_INSTANCES active instances
-        for (let i = 1; i <= MAX_CONCURRENT_INSTANCES; i++) {
-            createInstance({
-                id: `inst-max-${i}`,
-                masterSquadSlug: "test-squad",
-                worktreePath: `/tmp/wt/inst-max-${i}`,
-                branchName: `test-squad/instance/inst-max-${i}`,
-            });
-        }
-        assert.throws(() => createInstance({
-            id: "inst-over-limit",
-            masterSquadSlug: "test-squad",
-            worktreePath: "/tmp/wt/inst-over-limit",
-            branchName: "test-squad/instance/inst-over-limit",
-        }), /Max concurrent instances/);
-    });
-    it("does not count done/failed instances toward the limit", () => {
-        for (let i = 1; i <= MAX_CONCURRENT_INSTANCES; i++) {
-            const inst = createInstance({
-                id: `inst-done-${i}`,
-                masterSquadSlug: "test-squad",
-                worktreePath: `/tmp/wt/inst-done-${i}`,
-                branchName: `test-squad/instance/inst-done-${i}`,
-            });
-            updateInstanceStatus(inst.id, "done");
-        }
-        // Should not throw — all prior instances are done
-        assert.doesNotThrow(() => createInstance({
-            id: "inst-after-done",
-            masterSquadSlug: "test-squad",
-            worktreePath: "/tmp/wt/inst-after-done",
-            branchName: "test-squad/instance/inst-after-done",
-        }));
-    });
-});
-// ── getInstance ───────────────────────────────────────────────────────────────
-describe("getInstance", () => {
-    it("returns undefined for non-existent ID", () => {
-        assert.equal(getInstance("no-such-id"), undefined);
-    });
-    it("returns the correct instance after create", () => {
-        makeInstance("get-test");
-        const inst = getInstance("get-test");
-        assert.ok(inst);
-        assert.equal(inst.id, "get-test");
-    });
-});
-// ── listInstances ─────────────────────────────────────────────────────────────
-describe("listInstances", () => {
-    it("filters by slug and excludes done/failed by default", () => {
-        makeInstance("li-active-1");
-        makeInstance("li-active-2");
-        makeInstance("li-done", "test-squad", "done");
-        makeInstance("li-failed", "test-squad", "failed");
-        const active = listInstances("test-squad");
-        assert.equal(active.length, 2);
-        assert.ok(active.every((i) => i.status === "pending"));
-    });
-    it("includes completed instances when opted in", () => {
-        makeInstance("li-pending");
-        makeInstance("li-done2", "test-squad", "done");
-        const all = listInstances("test-squad", { includeCompleted: true });
-        assert.equal(all.length, 2);
-    });
-    it("does not include instances from other squads", () => {
-        getDb().prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("other-squad", "Other", "/tmp/other");
-        makeInstance("li-other", "other-squad");
-        makeInstance("li-mine");
-        const mine = listInstances("test-squad");
-        assert.equal(mine.length, 1);
-        assert.equal(mine[0].id, "li-mine");
-    });
-});
-// ── updateInstanceStatus ──────────────────────────────────────────────────────
-describe("updateInstanceStatus", () => {
-    it("sets completed_at for terminal status 'done'", () => {
-        makeInstance("upd-done");
-        updateInstanceStatus("upd-done", "done");
-        const inst = getInstance("upd-done");
-        assert.equal(inst.status, "done");
-        assert.ok(inst.completed_at !== null);
-    });
-    it("sets completed_at for terminal status 'failed'", () => {
-        makeInstance("upd-failed");
-        updateInstanceStatus("upd-failed", "failed");
-        const inst = getInstance("upd-failed");
-        assert.equal(inst.status, "failed");
-        assert.ok(inst.completed_at !== null);
-    });
-    it("does not set completed_at for non-terminal status 'active'", () => {
-        makeInstance("upd-active");
-        updateInstanceStatus("upd-active", "active");
-        const inst = getInstance("upd-active");
-        assert.equal(inst.status, "active");
-        assert.equal(inst.completed_at, null);
-    });
-});
-// ── logInstanceDecision + getInstanceDecisions ────────────────────────────────
-describe("logInstanceDecision / getInstanceDecisions", () => {
-    it("round-trips a decision with context", () => {
-        makeInstance("dec-inst");
-        logInstanceDecision("dec-inst", "use Jest for tests", "better DX");
-        const decisions = getInstanceDecisions("dec-inst");
-        assert.equal(decisions.length, 1);
-        assert.equal(decisions[0].decision, "use Jest for tests");
-        assert.equal(decisions[0].context, "better DX");
-        assert.equal(decisions[0].merged_to_master, 0);
-    });
-    it("stores null context when not provided", () => {
-        makeInstance("dec-nocontext");
-        logInstanceDecision("dec-nocontext", "some decision");
-        const decisions = getInstanceDecisions("dec-nocontext");
-        assert.equal(decisions[0].context, null);
-    });
-    it("returns decisions in ascending created_at order", () => {
-        makeInstance("dec-order");
-        logInstanceDecision("dec-order", "first");
-        logInstanceDecision("dec-order", "second");
-        const decisions = getInstanceDecisions("dec-order");
-        assert.equal(decisions[0].decision, "first");
-        assert.equal(decisions[1].decision, "second");
-    });
-});
-// ── mergeInstanceDecisions ────────────────────────────────────────────────────
-describe("mergeInstanceDecisions", () => {
-    it("copies decisions to squad_decisions with provenance tag and marks merged", () => {
-        makeInstance("merge-inst");
-        logInstanceDecision("merge-inst", "use SQLite transactions", "performance");
-        logInstanceDecision("merge-inst", "append-only log", "conflict-free");
-        const count = mergeInstanceDecisions("merge-inst", "test-squad");
-        assert.equal(count, 2);
-        const masterDecisions = getDecisions("test-squad");
-        assert.equal(masterDecisions.length, 2);
-        assert.ok(masterDecisions.some((d) => d.decision === "use SQLite transactions"));
-        assert.ok(masterDecisions.every((d) => d.context?.includes("[from instance: merge-inst]")));
-        const instDecisions = getInstanceDecisions("merge-inst");
-        assert.ok(instDecisions.every((d) => d.merged_to_master === 1));
-    });
-    it("is idempotent — calling twice does not double-merge", () => {
-        makeInstance("merge-idempotent");
-        logInstanceDecision("merge-idempotent", "idempotent decision");
-        mergeInstanceDecisions("merge-idempotent", "test-squad");
-        const second = mergeInstanceDecisions("merge-idempotent", "test-squad");
-        assert.equal(second, 0);
-        const masterDecisions = getDecisions("test-squad");
-        assert.equal(masterDecisions.length, 1);
-    });
-    it("returns 0 when there are no decisions to merge", () => {
-        makeInstance("merge-empty");
-        const count = mergeInstanceDecisions("merge-empty", "test-squad");
-        assert.equal(count, 0);
-    });
-});
-// ── deleteInstance ────────────────────────────────────────────────────────────
-describe("deleteInstance", () => {
-    it("removes the instance and its decisions", () => {
-        makeInstance("del-inst");
-        logInstanceDecision("del-inst", "a decision");
-        deleteInstance("del-inst");
-        assert.equal(getInstance("del-inst"), undefined);
-        assert.deepEqual(getInstanceDecisions("del-inst"), []);
-    });
-    it("is safe to call on a non-existent id", () => {
-        assert.doesNotThrow(() => deleteInstance("no-such-instance"));
-    });
-});
-// ── buildContextSnapshot ──────────────────────────────────────────────────────
-describe("buildContextSnapshot", () => {
-    it("returns a JSON object with decisions array", () => {
-        logDecision("test-squad", "use TypeScript everywhere", "consistency");
-        logDecision("test-squad", "prefer functional style");
-        const snapshot = buildContextSnapshot("test-squad");
-        const parsed = JSON.parse(snapshot);
-        assert.ok(Array.isArray(parsed.decisions));
-        assert.equal(parsed.decisions.length, 2);
-        assert.ok(parsed.decisions.some((d) => d.decision === "use TypeScript everywhere"));
-    });
-    it("returns empty decisions array for a squad with no decisions", () => {
-        const snapshot = buildContextSnapshot("test-squad");
-        const parsed = JSON.parse(snapshot);
-        assert.deepEqual(parsed.decisions, []);
-    });
-    it("respects the limit parameter", () => {
-        for (let i = 0; i < 10; i++) {
-            logDecision("test-squad", `decision ${i}`);
-        }
-        const snapshot = buildContextSnapshot("test-squad", 5);
-        const parsed = JSON.parse(snapshot);
-        assert.equal(parsed.decisions.length, 5);
-    });
-    it("includes wiki pages when they exist", async () => {
-        const { writePage, deletePage } = await import("../wiki/fs.js");
-        const testSlug = `test-squad-snap-${Date.now()}`;
-        const pagePath = `pages/squads/${testSlug}/rules.md`;
-        try {
-            writePage(pagePath, "# Rules\nNo force push.");
-            logDecision(testSlug, "test decision");
-            const snapshot = buildContextSnapshot(testSlug);
-            const parsed = JSON.parse(snapshot);
-            assert.ok(parsed.wiki);
-            assert.equal(parsed.wiki.length, 1);
-            assert.equal(parsed.wiki[0].path, pagePath);
-            assert.ok(parsed.wiki[0].content.includes("No force push"));
-        }
-        finally {
-            deletePage(pagePath);
-        }
-    });
-});
-// ── reconcileInstances ────────────────────────────────────────────────────────
-describe("reconcileInstances", () => {
-    it("marks pending/active/merging instances failed when worktree does not exist", () => {
-        // These worktree paths do not exist on disk
-        makeInstance("recon-pending"); // status: pending
-        makeInstance("recon-active", "test-squad", "active"); // status: active
-        makeInstance("recon-merging", "test-squad", "merging"); // status: merging
-        const cleaned = reconcileInstances();
-        assert.equal(cleaned, 3);
-        assert.equal(getInstance("recon-pending").status, "failed");
-        assert.equal(getInstance("recon-active").status, "failed");
-        assert.equal(getInstance("recon-merging").status, "failed");
-    });
-    it("does not touch already-terminal instances", () => {
-        makeInstance("recon-done", "test-squad", "done");
-        makeInstance("recon-failed", "test-squad", "failed");
-        const cleaned = reconcileInstances();
-        assert.equal(cleaned, 0);
-    });
-    it("returns 0 when all non-terminal instances have valid worktrees", () => {
-        // Use a path that actually exists (tmpDir was created above)
-        createInstance({
-            id: "recon-exists",
-            masterSquadSlug: "test-squad",
-            worktreePath: tmpDir, // this path exists on disk
-            branchName: "test-squad/instance/recon-exists",
-        });
-        const cleaned = reconcileInstances();
-        assert.equal(cleaned, 0);
-        assert.equal(getInstance("recon-exists").status, "pending");
-    });
-});
-//# sourceMappingURL=instances.test.js.map

package/dist/store/io-schedules.js

@@ -1,63 +0,0 @@
-import { getDb } from "./db.js";
-export function createIoSchedule(input) {
-    const db = getDb();
-    const info = db
-        .prepare(`INSERT INTO io_schedules
-         (name, cron_expr, prompt, notes, enabled, next_run_at)
-       VALUES (?, ?, ?, ?, 1, ?)`)
-        .run(input.name, input.cronExpr, input.prompt, input.notes ?? null, input.nextRunAt);
-    const id = Number(info.lastInsertRowid);
-    return getIoSchedule(id);
-}
-export function getIoSchedule(id) {
-    return getDb()
-        .prepare("SELECT * FROM io_schedules WHERE id = ?")
-        .get(id);
-}
-export function listIoSchedules() {
-    return getDb()
-        .prepare("SELECT * FROM io_schedules ORDER BY id ASC")
-        .all();
-}
-export function listDueIoSchedules(now) {
-    return getDb()
-        .prepare(`SELECT * FROM io_schedules
-        WHERE enabled = 1
-          AND next_run_at IS NOT NULL
-          AND next_run_at <= ?
-        ORDER BY next_run_at ASC`)
-        .all(now.toISOString());
-}
-export function deleteIoSchedule(id) {
-    const info = getDb()
-        .prepare("DELETE FROM io_schedules WHERE id = ?")
-        .run(id);
-    return info.changes > 0;
-}
-export function setIoScheduleEnabled(id, enabled) {
-    const info = getDb()
-        .prepare("UPDATE io_schedules SET enabled = ? WHERE id = ?")
-        .run(enabled ? 1 : 0, id);
-    return info.changes > 0;
-}
-export function recordIoScheduleRun(id, ranAt, nextRunAt) {
-    getDb()
-        .prepare("UPDATE io_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
-        .run(ranAt.toISOString(), nextRunAt, id);
-}
-export function updateIoScheduleNextRun(id, nextRunAt) {
-    getDb()
-        .prepare("UPDATE io_schedules SET next_run_at = ? WHERE id = ?")
-        .run(nextRunAt, id);
-}
-/**
- * Overwrite both last_run_at and next_run_at directly. Unlike
- * recordIoScheduleRun this accepts NULL for last_run_at, which is needed when
- * restoring a schedule's "never run" state after a manual run_now.
- */
-export function setIoScheduleTimestamps(id, lastRunAt, nextRunAt) {
-    getDb()
-        .prepare("UPDATE io_schedules SET last_run_at = ?, next_run_at = ? WHERE id = ?")
-        .run(lastRunAt, nextRunAt, id);
-}
-//# sourceMappingURL=io-schedules.js.map

package/dist/store/notifications.js

@@ -1,79 +0,0 @@
-import { getDb } from "./db.js";
-/**
- * Insert a new background notification. Returns the inserted row including
- * the autoincrement id and DB-assigned created_at timestamp. source_ref
- * should be a JSON string or null.
- */
-export function insertNotification(input) {
-    const db = getDb();
-    const info = db
-        .prepare(`INSERT INTO background_notifications (source_type, source_ref, title, text)
-       VALUES (?, ?, ?, ?)`)
-        .run(input.source_type, input.source_ref, input.title, input.text);
-    return db
-        .prepare("SELECT * FROM background_notifications WHERE id = ?")
-        .get(info.lastInsertRowid);
-}
-/**
- * List the most recent notifications, newest first. Default limit 50.
- */
-export function listRecentNotifications(limit = 50) {
-    return getDb()
-        .prepare("SELECT * FROM background_notifications ORDER BY created_at DESC, id DESC LIMIT ?")
-        .all(limit);
-}
-/**
- * List unread notifications (read_at IS NULL), newest first.
- */
-export function listUnreadNotifications() {
-    return getDb()
-        .prepare("SELECT * FROM background_notifications WHERE read_at IS NULL ORDER BY created_at DESC, id DESC")
-        .all();
-}
-/**
- * Count unread notifications. Cheap — uses COUNT(*).
- */
-export function countUnreadNotifications() {
-    const row = getDb()
-        .prepare("SELECT COUNT(*) AS n FROM background_notifications WHERE read_at IS NULL")
-        .get();
-    return row.n;
-}
-/**
- * Mark a single notification read. Returns true if the row exists (whether
- * it was already read or just now marked), false if no such id exists.
- */
-export function markNotificationRead(id) {
-    const db = getDb();
-    const info = db
-        .prepare("UPDATE background_notifications SET read_at = CURRENT_TIMESTAMP WHERE id = ? AND read_at IS NULL")
-        .run(id);
-    if (info.changes > 0)
-        return true;
-    // Already read — verify the row exists at all
-    const exists = db
-        .prepare("SELECT id FROM background_notifications WHERE id = ?")
-        .get(id);
-    return exists !== undefined;
-}
-/**
- * Mark every unread notification read. Returns the number of rows affected.
- */
-export function markAllNotificationsRead() {
-    const info = getDb()
-        .prepare("UPDATE background_notifications SET read_at = CURRENT_TIMESTAMP WHERE read_at IS NULL")
-        .run();
-    return info.changes;
-}
-/**
- * Delete notifications older than `olderThanDays` days. Returns rows deleted.
- * Used by a future retention sweep.
- */
-export function pruneOldNotifications(olderThanDays) {
-    const info = getDb()
-        .prepare(`DELETE FROM background_notifications
-       WHERE created_at < datetime('now', ? || ' days')`)
-        .run(`-${olderThanDays}`);
-    return info.changes;
-}
-//# sourceMappingURL=notifications.js.map

package/dist/store/notifications.test.js

@@ -1,197 +0,0 @@
-/**
- * Tests for src/store/notifications.ts — SQLite CRUD helpers.
- *
- * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
- * fresh tmp file, ensuring these tests never touch ~/.io/io.db.
- */
-import { before, after, beforeEach, describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { setDbPathForTests, closeDb, getDb } from "./db.js";
-import { insertNotification, listRecentNotifications, listUnreadNotifications, countUnreadNotifications, markNotificationRead, markAllNotificationsRead, pruneOldNotifications, } from "./notifications.js";
-// ── DB isolation ────────────────────────────────────────────────────────────
-let tmpDir;
-before(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "io-notifs-test-"));
-    setDbPathForTests(join(tmpDir, "io.db"));
-});
-// Wipe all notifications between tests for a clean slate.
-beforeEach(() => {
-    getDb().prepare("DELETE FROM background_notifications").run();
-});
-after(() => {
-    closeDb();
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-// ── Helpers ─────────────────────────────────────────────────────────────────
-function makeNotif(overrides = {}) {
-    return insertNotification({
-        source_type: "io-schedule",
-        source_ref: JSON.stringify({ scheduleId: 1 }),
-        title: "Test Notification",
-        text: "This is the notification body.",
-        ...overrides,
-    });
-}
-// ── insertNotification ───────────────────────────────────────────────────────
-describe("insertNotification", () => {
-    it("returns a row with autoincrement id and created_at timestamp", () => {
-        const row = makeNotif();
-        assert.ok(typeof row.id === "number" && row.id > 0, "id should be a positive integer");
-        assert.ok(row.created_at, "created_at should be set");
-        assert.equal(row.title, "Test Notification");
-        assert.equal(row.text, "This is the notification body.");
-        assert.equal(row.read_at, null);
-    });
-    it("ids are autoincremented across inserts", () => {
-        const a = makeNotif();
-        const b = makeNotif();
-        assert.ok(b.id > a.id, "second id should be greater than first");
-    });
-    it("accepts source_ref: null", () => {
-        const row = makeNotif({ source_ref: null });
-        assert.equal(row.source_ref, null);
-    });
-    it("stores source_type correctly", () => {
-        const row = makeNotif({ source_type: "squad-schedule" });
-        assert.equal(row.source_type, "squad-schedule");
-    });
-});
-// ── listRecentNotifications ──────────────────────────────────────────────────
-describe("listRecentNotifications", () => {
-    it("returns newest first", () => {
-        const a = makeNotif({ title: "First" });
-        const b = makeNotif({ title: "Second" });
-        const c = makeNotif({ title: "Third" });
-        const rows = listRecentNotifications();
-        assert.equal(rows[0].id, c.id, "newest should be first");
-        assert.equal(rows[rows.length - 1].id, a.id, "oldest should be last");
-    });
-    it("default limit is 50", () => {
-        for (let i = 0; i < 55; i++)
-            makeNotif({ title: `N${i}` });
-        const rows = listRecentNotifications();
-        assert.equal(rows.length, 50);
-    });
-    it("explicit limit is honored", () => {
-        for (let i = 0; i < 10; i++)
-            makeNotif({ title: `N${i}` });
-        const rows = listRecentNotifications(3);
-        assert.equal(rows.length, 3);
-    });
-});
-// ── countUnreadNotifications ─────────────────────────────────────────────────
-describe("countUnreadNotifications", () => {
-    it("starts at zero on a clean DB", () => {
-        assert.equal(countUnreadNotifications(), 0);
-    });
-    it("increases on insert", () => {
-        makeNotif();
-        assert.equal(countUnreadNotifications(), 1);
-        makeNotif();
-        assert.equal(countUnreadNotifications(), 2);
-    });
-    it("decreases when a notification is marked read", () => {
-        const a = makeNotif();
-        makeNotif();
-        assert.equal(countUnreadNotifications(), 2);
-        markNotificationRead(a.id);
-        assert.equal(countUnreadNotifications(), 1);
-    });
-});
-// ── markNotificationRead ─────────────────────────────────────────────────────
-describe("markNotificationRead", () => {
-    it("returns false on a non-existent id", () => {
-        assert.equal(markNotificationRead(999999), false);
-    });
-    it("returns true on an existing unread notification", () => {
-        const row = makeNotif();
-        assert.equal(markNotificationRead(row.id), true);
-    });
-    it("is idempotent — returns true even if already read", () => {
-        const row = makeNotif();
-        assert.equal(markNotificationRead(row.id), true);
-        assert.equal(markNotificationRead(row.id), true, "second call should still return true");
-    });
-    it("sets read_at on the row", () => {
-        const row = makeNotif();
-        markNotificationRead(row.id);
-        const updated = getDb()
-            .prepare("SELECT read_at FROM background_notifications WHERE id = ?")
-            .get(row.id);
-        assert.ok(updated.read_at, "read_at should be set after marking read");
-    });
-});
-// ── markAllNotificationsRead ─────────────────────────────────────────────────
-describe("markAllNotificationsRead", () => {
-    it("returns the count of newly-marked rows", () => {
-        makeNotif();
-        makeNotif();
-        makeNotif();
-        assert.equal(markAllNotificationsRead(), 3);
-    });
-    it("subsequent call returns 0 (all already read)", () => {
-        makeNotif();
-        makeNotif();
-        markAllNotificationsRead();
-        assert.equal(markAllNotificationsRead(), 0);
-    });
-    it("only marks unread rows — pre-read rows not re-touched", () => {
-        const a = makeNotif();
-        makeNotif();
-        markNotificationRead(a.id); // mark one manually first
-        const count = markAllNotificationsRead(); // should only mark the remaining 1
-        assert.equal(count, 1);
-    });
-});
-// ── listUnreadNotifications ──────────────────────────────────────────────────
-describe("listUnreadNotifications", () => {
-    it("excludes read rows", () => {
-        const a = makeNotif({ title: "A" });
-        const b = makeNotif({ title: "B" });
-        markNotificationRead(a.id);
-        const unread = listUnreadNotifications();
-        assert.ok(!unread.some((r) => r.id === a.id), "read row should not appear");
-        assert.ok(unread.some((r) => r.id === b.id), "unread row should appear");
-    });
-    it("returns newest first", () => {
-        const a = makeNotif({ title: "A" });
-        const b = makeNotif({ title: "B" });
-        const rows = listUnreadNotifications();
-        assert.equal(rows[0].id, b.id);
-        assert.equal(rows[1].id, a.id);
-    });
-    it("returns empty array when all are read", () => {
-        makeNotif();
-        makeNotif();
-        markAllNotificationsRead();
-        assert.deepEqual(listUnreadNotifications(), []);
-    });
-});
-// ── pruneOldNotifications ─────────────────────────────────────────────────────
-describe("pruneOldNotifications", () => {
-    it("deletes rows older than the threshold and returns the count", () => {
-        const old = makeNotif({ title: "Old" });
-        makeNotif({ title: "Recent" }); // stays untouched
-        // Back-date the 'old' row to 10 days ago
-        getDb()
-            .prepare("UPDATE background_notifications SET created_at = datetime('now', '-10 days') WHERE id = ?")
-            .run(old.id);
-        const deleted = pruneOldNotifications(7); // prune rows older than 7 days
-        assert.equal(deleted, 1, "should delete exactly the back-dated row");
-        const remaining = listRecentNotifications();
-        assert.ok(!remaining.some((r) => r.id === old.id), "old row should be gone");
-        assert.ok(remaining.some((r) => r.title === "Recent"), "recent row should remain");
-    });
-    it("returns 0 when nothing is old enough to prune", () => {
-        makeNotif();
-        makeNotif();
-        assert.equal(pruneOldNotifications(7), 0);
-    });
-    it("is safe on an empty table", () => {
-        assert.equal(pruneOldNotifications(1), 0);
-    });
-});
-//# sourceMappingURL=notifications.test.js.map