heyio 0.5.0 → 0.8.0

package/dist/notify.test.js

@@ -0,0 +1,232 @@
+/**
+ * Tests for src/notify.ts — isMeaningfulOutput heuristic and notifyBackground
+ * dispatch routing.
+ *
+ * DB isolation: setDbPathForTests() redirects the SQLite singleton to a
+ * fresh tmp file so these tests never touch ~/.io/io.db.
+ */
+import { before, after, afterEach, 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 } from "./store/db.js";
+import { config } from "./config.js";
+import { isMeaningfulOutput, notifyBackground, setTelegramSender, setTuiSender, setSseBroadcaster, _resetNotifySendersForTests, } from "./notify.js";
+// ── DB isolation ────────────────────────────────────────────────────────────
+let tmpDir;
+before(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "io-notify-test-"));
+    setDbPathForTests(join(tmpDir, "io.db"));
+});
+after(() => {
+    closeDb();
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+// ── Config teardown ─────────────────────────────────────────────────────────
+const origMode = config.backgroundNotifyMode;
+const origTelegram = config.backgroundNotifyTelegram;
+const origTui = config.backgroundNotifyTui;
+afterEach(() => {
+    config.backgroundNotifyMode = origMode;
+    config.backgroundNotifyTelegram = origTelegram;
+    config.backgroundNotifyTui = origTui;
+    _resetNotifySendersForTests();
+});
+// ── isMeaningfulOutput ───────────────────────────────────────────────────────
+describe("isMeaningfulOutput", () => {
+    describe("returns false for short/empty input", () => {
+        it("empty string", () => assert.equal(isMeaningfulOutput(""), false));
+        it("whitespace only", () => assert.equal(isMeaningfulOutput("   "), false));
+        it("under 20 chars", () => assert.equal(isMeaningfulOutput("short"), false));
+        it("exactly 19 chars", () => assert.equal(isMeaningfulOutput("a".repeat(19)), false));
+    });
+    describe("returns false for heartbeat phrases", () => {
+        const phrases = [
+            "no active tasks",
+            "no active task",
+            "nothing to report.",
+            "Nothing to report.",
+            "ALL CLEAR",
+            "no updates",
+            "no update",
+            "no changes",
+            "no change",
+            "idle",
+            "IDLE",
+            "heartbeat",
+            "ok",
+            "OK",
+        ];
+        for (const phrase of phrases) {
+            it(`"${phrase}"`, () => assert.equal(isMeaningfulOutput(phrase), false));
+        }
+    });
+    it("returns false when heartbeat phrase is first non-empty line (blank preamble)", () => {
+        const text = "\n\n  \nno active tasks\nsome more content here that is long";
+        assert.equal(isMeaningfulOutput(text), false);
+    });
+    it("returns false when heartbeat is surrounded by whitespace on its line", () => {
+        assert.equal(isMeaningfulOutput("  idle  "), false);
+    });
+    it("returns true for normal multi-sentence prose ≥20 chars", () => {
+        assert.equal(isMeaningfulOutput("Task 1 completed successfully. Moving to step 2."), true);
+    });
+    it("returns true for a bulleted report whose first line is not a heartbeat", () => {
+        const text = [
+            "Squad status update:",
+            "- Lion-O: working on PR #80",
+            "- Tygra: reviewing PR #79",
+            "- Cheetara: idle",
+        ].join("\n");
+        assert.equal(isMeaningfulOutput(text), true);
+    });
+    it("returns true for exactly 20 chars", () => {
+        assert.equal(isMeaningfulOutput("a".repeat(20)), true);
+    });
+});
+// ── notifyBackground dispatch routing ───────────────────────────────────────
+const MEANINGFUL_TEXT = "Squad task monitor: PR #80 merged. Lion-O completed the delegation stats feature. All checks passing.";
+const HEARTBEAT_TEXT = "no active tasks";
+const SOURCE = {
+    type: "squad-schedule",
+    scheduleId: 7,
+    squadSlug: "michaeljolley-io",
+    scheduleName: "Active Task Monitor",
+};
+describe("notifyBackground", () => {
+    it('mode="off" → skipped:"off", no senders called, no row inserted', async () => {
+        config.backgroundNotifyMode = "off";
+        let called = false;
+        setSseBroadcaster(() => { called = true; });
+        setTuiSender(() => { called = true; });
+        setTelegramSender(async () => { called = true; });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.equal(result.skipped, "off");
+        assert.equal(result.id, undefined);
+        assert.equal(called, false);
+    });
+    it("empty text → skipped:empty, no row inserted", async () => {
+        config.backgroundNotifyMode = "all";
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: "   " });
+        assert.equal(result.skipped, "empty");
+        assert.equal(result.id, undefined);
+    });
+    it('mode="meaningful" + heartbeat text → skipped:"not-meaningful", no row', async () => {
+        config.backgroundNotifyMode = "meaningful";
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: HEARTBEAT_TEXT });
+        assert.equal(result.skipped, "not-meaningful");
+        assert.equal(result.id, undefined);
+    });
+    it('mode="all" + heartbeat + all senders → all dispatch, row inserted', async () => {
+        config.backgroundNotifyMode = "all";
+        config.backgroundNotifyTelegram = true;
+        config.backgroundNotifyTui = true;
+        const calls = { sse: false, tui: false, telegram: false };
+        setSseBroadcaster(() => { calls.sse = true; });
+        setTuiSender(() => { calls.tui = true; });
+        setTelegramSender(async () => { calls.telegram = true; });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: HEARTBEAT_TEXT });
+        assert.ok(result.id, "should return a row id");
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(result.dispatched.tui, true);
+        assert.equal(result.dispatched.telegram, true);
+        assert.equal(calls.sse, true);
+        assert.equal(calls.tui, true);
+        assert.equal(calls.telegram, true);
+        assert.equal(result.skipped, undefined);
+    });
+    it('mode="meaningful" + meaningful text + all senders → all dispatch', async () => {
+        config.backgroundNotifyMode = "meaningful";
+        config.backgroundNotifyTelegram = true;
+        config.backgroundNotifyTui = true;
+        const calls = { sse: false, tui: false, telegram: false };
+        setSseBroadcaster(() => { calls.sse = true; });
+        setTuiSender(() => { calls.tui = true; });
+        setTelegramSender(async () => { calls.telegram = true; });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.ok(result.id);
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(result.dispatched.tui, true);
+        assert.equal(result.dispatched.telegram, true);
+    });
+    it("backgroundNotifyTelegram=false → telegram skipped, tui+sse still fire", async () => {
+        config.backgroundNotifyMode = "all";
+        config.backgroundNotifyTelegram = false;
+        config.backgroundNotifyTui = true;
+        const calls = { sse: false, tui: false, telegram: false };
+        setSseBroadcaster(() => { calls.sse = true; });
+        setTuiSender(() => { calls.tui = true; });
+        setTelegramSender(async () => { calls.telegram = true; });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.equal(result.dispatched.telegram, false, "telegram should be skipped");
+        assert.equal(result.dispatched.tui, true);
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(calls.telegram, false);
+    });
+    it("backgroundNotifyTui=false → tui skipped, telegram+sse still fire", async () => {
+        config.backgroundNotifyMode = "all";
+        config.backgroundNotifyTelegram = true;
+        config.backgroundNotifyTui = false;
+        const calls = { sse: false, tui: false, telegram: false };
+        setSseBroadcaster(() => { calls.sse = true; });
+        setTuiSender(() => { calls.tui = true; });
+        setTelegramSender(async () => { calls.telegram = true; });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.equal(result.dispatched.tui, false, "tui should be skipped");
+        assert.equal(result.dispatched.telegram, true);
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(calls.tui, false);
+    });
+    it("telegram sender throws → dispatched.telegram=false, others true, no rethrow", async () => {
+        config.backgroundNotifyMode = "all";
+        config.backgroundNotifyTelegram = true;
+        config.backgroundNotifyTui = true;
+        const calls = { sse: false, tui: false };
+        setSseBroadcaster(() => { calls.sse = true; });
+        setTuiSender(() => { calls.tui = true; });
+        setTelegramSender(async () => { throw new Error("telegram down"); });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.equal(result.dispatched.telegram, false);
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(result.dispatched.tui, true);
+        assert.ok(result.id, "row should still be inserted");
+    });
+    it("TUI sender throws → dispatched.tui=false, others true, no rethrow", async () => {
+        config.backgroundNotifyMode = "all";
+        config.backgroundNotifyTelegram = true;
+        config.backgroundNotifyTui = true;
+        setSseBroadcaster(() => { });
+        setTuiSender(() => { throw new Error("tui down"); });
+        setTelegramSender(async () => { });
+        const result = await notifyBackground({ source: SOURCE, title: "T", text: MEANINGFUL_TEXT });
+        assert.equal(result.dispatched.tui, false);
+        assert.equal(result.dispatched.sse, true);
+        assert.equal(result.dispatched.telegram, true);
+    });
+    it("squad-schedule source detail round-trips to SSE broadcaster payload", async () => {
+        config.backgroundNotifyMode = "all";
+        let capturedPayload;
+        setSseBroadcaster((payload) => { capturedPayload = payload; });
+        const source = {
+            type: "squad-schedule",
+            scheduleId: 42,
+            squadSlug: "thundercats",
+            scheduleName: "Morning Standup",
+        };
+        const result = await notifyBackground({
+            source,
+            title: "Morning Standup Result",
+            text: MEANINGFUL_TEXT,
+        });
+        assert.ok(capturedPayload, "SSE broadcaster should have been called");
+        assert.equal(capturedPayload.id, result.id);
+        assert.equal(capturedPayload.source.type, "squad-schedule");
+        assert.equal(capturedPayload.source.scheduleId, 42);
+        assert.equal(capturedPayload.source.squadSlug, "thundercats");
+        assert.equal(capturedPayload.source.scheduleName, "Morning Standup");
+        assert.equal(capturedPayload.title, "Morning Standup Result");
+        assert.ok(capturedPayload.createdAt, "createdAt should be set");
+    });
+});
+//# sourceMappingURL=notify.test.js.map

package/dist/store/db.js

@@ -1,13 +1,29 @@
 import Database from "better-sqlite3";
 import { mkdirSync } from "fs";
+import { dirname } from "path";
 import { DB_PATH, IO_HOME } from "../paths.js";
 let db = null;
 let insertCount = 0;
+let dbPathOverride = null;
+/**
+ * Override the DB path for tests. Closes the existing connection (if any)
+ * so the next getDb() call opens a fresh DB at the given path.
+ * Never call this in production code.
+ */
+export function setDbPathForTests(path) {
+    if (db) {
+        db.close();
+        db = null;
+    }
+    dbPathOverride = path;
+}
 export function getDb() {
     if (db)
         return db;
-    mkdirSync(IO_HOME, { recursive: true });
-    db = new Database(DB_PATH);
+    const resolvedPath = dbPathOverride ?? DB_PATH;
+    const resolvedHome = dbPathOverride ? dirname(resolvedPath) : IO_HOME;
+    mkdirSync(resolvedHome, { recursive: true });
+    db = new Database(resolvedPath);
     db.pragma("journal_mode = WAL");
     db.exec(`
     CREATE TABLE IF NOT EXISTS io_state (
@@ -109,6 +125,35 @@ export function getDb() {
     )`,
         `CREATE INDEX IF NOT EXISTS idx_io_schedules_due
        ON io_schedules (enabled, next_run_at)`,
+        `CREATE VIEW IF NOT EXISTS agent_stats AS
+SELECT agent_slug,
+       COUNT(*)        AS task_count,
+       MAX(started_at) AS last_delegated_at
+FROM agent_tasks
+GROUP BY agent_slug`,
+        `CREATE TABLE IF NOT EXISTS background_notifications (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_type TEXT NOT NULL,
+      source_ref TEXT,
+      title TEXT NOT NULL,
+      text TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      read_at DATETIME
+    )`,
+        `CREATE INDEX IF NOT EXISTS idx_bg_notifications_unread ON background_notifications(read_at, created_at)`,
+        `CREATE TABLE IF NOT EXISTS schedule_runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      schedule_type TEXT NOT NULL,
+      schedule_id INTEGER NOT NULL,
+      schedule_name TEXT NOT NULL,
+      squad_slug TEXT,
+      status TEXT NOT NULL DEFAULT 'running',
+      error_text TEXT,
+      notification_id INTEGER,
+      started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      completed_at DATETIME
+    )`,
+        `CREATE INDEX IF NOT EXISTS idx_schedule_runs_lookup ON schedule_runs(schedule_type, schedule_id, started_at)`,
     ];
     for (const migration of migrations) {
         try {

package/dist/store/notifications.js

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,197 @@
+/**
+ * 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

package/dist/store/schedule-runs.js

@@ -0,0 +1,46 @@
+import { getDb } from "./db.js";
+/** Create a new run in 'running' status. Returns the row. */
+export function startScheduleRun(input) {
+    const db = getDb();
+    const info = db
+        .prepare(`INSERT INTO schedule_runs (schedule_type, schedule_id, schedule_name, squad_slug)
+       VALUES (?, ?, ?, ?)`)
+        .run(input.schedule_type, input.schedule_id, input.schedule_name, input.squad_slug ?? null);
+    return db
+        .prepare("SELECT * FROM schedule_runs WHERE id = ?")
+        .get(info.lastInsertRowid);
+}
+/** Mark a run complete (success). Optionally link a notification_id. */
+export function completeScheduleRun(id, notificationId) {
+    getDb()
+        .prepare(`UPDATE schedule_runs
+       SET status = 'done', completed_at = CURRENT_TIMESTAMP, notification_id = ?
+       WHERE id = ?`)
+        .run(notificationId ?? null, id);
+}
+/** Mark a run failed with an error message. */
+export function failScheduleRun(id, errorText) {
+    getDb()
+        .prepare(`UPDATE schedule_runs
+       SET status = 'failed', completed_at = CURRENT_TIMESTAMP, error_text = ?
+       WHERE id = ?`)
+        .run(errorText, id);
+}
+/** Get last N runs for a specific schedule. Newest first. */
+export function getScheduleRuns(scheduleType, scheduleId, limit = 10) {
+    return getDb()
+        .prepare(`SELECT * FROM schedule_runs
+       WHERE schedule_type = ? AND schedule_id = ?
+       ORDER BY started_at DESC
+       LIMIT ?`)
+        .all(scheduleType, scheduleId, limit);
+}
+/** Prune runs older than the given number of days. Returns rows deleted. */
+export function pruneOldScheduleRuns(olderThanDays) {
+    const info = getDb()
+        .prepare(`DELETE FROM schedule_runs
+       WHERE started_at < datetime('now', '-' || ? || ' days')`)
+        .run(olderThanDays);
+    return info.changes;
+}
+//# sourceMappingURL=schedule-runs.js.map

package/dist/store/squads.js

@@ -93,6 +93,16 @@ export function updateAgentStatus(squadSlug, characterName, status) {
         .prepare("UPDATE squad_agents SET status = ? WHERE squad_slug = ? AND character_name = ?")
         .run(status, squadSlug, characterName);
 }
+/**
+ * Clear an agent's persisted copilot_session_id. Used during error recovery
+ * so the next task creates a fresh session instead of trying to resume a
+ * poisoned one.
+ */
+export function clearAgentSession(squadSlug, characterName) {
+    getDb()
+        .prepare("UPDATE squad_agents SET copilot_session_id = NULL WHERE squad_slug = ? AND character_name = ?")
+        .run(squadSlug, characterName);
+}
 /**
  * Reset any agent left in a non-idle status from a previous daemon run.
  * The in-memory Copilot sessions don't survive a restart, so persisted