heyio 0.6.0 → 0.8.0

package/dist/copilot/skills.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, rmSync, statSync } from "fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { join, basename } from "path";
 import { execSync } from "child_process";
 import { SKILLS_DIR } from "../paths.js";
@@ -80,11 +80,85 @@ export function listSkills() {
     }
     return skills;
 }
+const GITHUB_BLOB_RE = /^https:\/\/github\.com\/([^\/]+)\/([^\/]+)\/blob\/([^\/]+)\/(.+\/)?SKILL\.md$/i;
+const RAW_GH_RE = /^https:\/\/raw\.githubusercontent\.com\/([^\/]+)\/([^\/]+)\/([^\/]+)\/(.+\/)?SKILL\.md$/i;
+const GENERIC_SKILL_MD_RE = /\/SKILL\.md$/i;
+function deriveSlug(repo, pathPrefix) {
+    if (!pathPrefix)
+        return repo;
+    const segments = pathPrefix.replace(/\/$/, "").split("/").filter(Boolean);
+    const last = segments[segments.length - 1];
+    return last ? `${repo}-${last}` : repo;
+}
 /**
- * Clone a git repo into SKILLS_DIR and return the installed skill info.
- * Throws if the cloned repo does not contain a SKILL.md file.
+ * Determine whether the input URL points to a full repo or a specific
+ * SKILL.md file. For GitHub blob URLs the raw download URL is derived
+ * automatically.
  */
-export async function installSkill(repoUrl) {
+export function parseSkillUrl(input) {
+    const blobMatch = input.match(GITHUB_BLOB_RE);
+    if (blobMatch) {
+        const [, owner, repo, branch, pathPrefix] = blobMatch;
+        const rawUrl = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${pathPrefix ?? ""}SKILL.md`;
+        return { type: "file", rawUrl, slug: deriveSlug(repo, pathPrefix) };
+    }
+    const rawMatch = input.match(RAW_GH_RE);
+    if (rawMatch) {
+        const [, _owner, repo, _branch, pathPrefix] = rawMatch;
+        return { type: "file", rawUrl: input, slug: deriveSlug(repo, pathPrefix) };
+    }
+    if (GENERIC_SKILL_MD_RE.test(input)) {
+        if (!input.startsWith("https://")) {
+            throw new Error("Only https:// URLs are supported for SKILL.md installs.");
+        }
+        const urlObj = new URL(input);
+        const segments = urlObj.pathname.split("/").filter(Boolean);
+        // Use the segment before SKILL.md, or the hostname as slug fallback
+        const slug = segments.length >= 2
+            ? segments[segments.length - 2]
+            : urlObj.hostname.replace(/\./g, "-");
+        return { type: "file", rawUrl: input, slug };
+    }
+    return { type: "repo", url: input };
+}
+async function installSkillFromFile(rawUrl, slug) {
+    if (!rawUrl.startsWith("https://")) {
+        throw new Error("Only https:// URLs are supported for SKILL.md installs.");
+    }
+    const destDir = join(SKILLS_DIR, slug);
+    if (existsSync(destDir)) {
+        throw new Error(`Skill "${slug}" is already installed.`);
+    }
+    const response = await fetch(rawUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch SKILL.md from ${rawUrl} (HTTP ${response.status})`);
+    }
+    const content = await response.text();
+    // Validate: at least one markdown heading in the first 10 lines
+    const first10 = content.split(/\r?\n/).slice(0, 10);
+    if (!first10.some((line) => /^#\s+/.test(line))) {
+        throw new Error("URL does not appear to contain a valid SKILL.md file.");
+    }
+    mkdirSync(destDir, { recursive: true });
+    writeFileSync(join(destDir, "SKILL.md"), content, "utf-8");
+    const { name, description } = parseSkillMd(content);
+    return {
+        name: name || slug,
+        slug,
+        description,
+        path: destDir,
+    };
+}
+/**
+ * Install a skill from a git repo URL or a direct SKILL.md file URL.
+ * Throws if the repo/file does not contain a valid SKILL.md.
+ */
+export async function installSkill(input) {
+    const parsed = parseSkillUrl(input);
+    if (parsed.type === "file") {
+        return installSkillFromFile(parsed.rawUrl, parsed.slug);
+    }
+    const repoUrl = parsed.url;
     const repoName = basename(repoUrl, ".git").replace(/\.git$/, "");
     const destDir = join(SKILLS_DIR, repoName);
     execSync(`git clone ${repoUrl} ${destDir}`, { stdio: "pipe" });

package/dist/copilot/tools.js

@@ -776,10 +776,10 @@ export function createTools(deps) {
         },
     });
     const skillInstall = defineTool("skill_install", {
-        description: "Install a skill from a git repository URL. The repo must contain a SKILL.md file.",
+        description: "Install a skill from a git repository URL or a direct SKILL.md file URL. Accepts full repo URLs (clones the repo) and GitHub blob/raw URLs pointing to a specific SKILL.md (fetches just that file).",
         skipPermission: true,
         parameters: z.object({
-            repo_url: z.string().describe("Git repository URL (e.g., https://github.com/user/my-skill.git)"),
+            repo_url: z.string().describe("Git repository URL (e.g., https://github.com/user/my-skill.git) or direct SKILL.md URL (e.g., https://github.com/user/repo/blob/main/skills/my-skill/SKILL.md)"),
         }),
         handler: async ({ repo_url }) => {
             console.error(`[io] skill_install called: ${repo_url}`);

package/dist/daemon.js

@@ -1,7 +1,11 @@
 import { getClient, stopClient } from "./copilot/client.js";
 import { initOrchestrator, sendToOrchestrator, shutdownOrchestrator } from "./copilot/orchestrator.js";
-import { startApiServer, setMessageHandler as setApiHandler } from "./api/server.js";
-import { createBot, startBot, stopBot, sendProactiveMessage, setMessageHandler as setTelegramHandler } from "./telegram/bot.js";
+import { startApiServer, setMessageHandler as setApiHandler, broadcastNotificationToSSE } from "./api/server.js";
+import { createBot, startBot, stopBot, sendProactiveMessage, sendBackgroundNotification, setMessageHandler as setTelegramHandler } from "./telegram/bot.js";
+import { setTelegramSender, setTuiSender, setSseBroadcaster } from "./notify.js";
+import { pruneOldScheduleRuns } from "./store/schedule-runs.js";
+import { pruneOldNotifications } from "./store/notifications.js";
+import { printBackgroundNotification } from "./tui/index.js";
 import { getDb, closeDb } from "./store/db.js";
 import { clearStaleTasks } from "./store/tasks.js";
 import { reconcileAgentStatuses, reconcileSquadStatuses } from "./store/squads.js";
@@ -118,6 +122,35 @@ export async function startDaemon() {
     startScheduler();
     // Start the IO-level scheduler (squad-independent recurring tasks).
     startIoScheduler();
+    // Background-notification dispatch surfaces (issue #78)
+    setSseBroadcaster((p) => broadcastNotificationToSSE(p));
+    setTuiSender((opts) => printBackgroundNotification(opts));
+    setTelegramSender((opts) => sendBackgroundNotification(opts));
+    // Daily cleanup — prune schedule runs and notifications older than 30 days
+    const PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+    const PRUNE_RETENTION_DAYS = 30;
+    const pruneTimer = setInterval(() => {
+        try {
+            const runsDeleted = pruneOldScheduleRuns(PRUNE_RETENTION_DAYS);
+            const notificationsDeleted = pruneOldNotifications(PRUNE_RETENTION_DAYS);
+            if (runsDeleted > 0 || notificationsDeleted > 0) {
+                console.log(`[prune] Cleaned up ${runsDeleted} schedule runs and ${notificationsDeleted} notifications older than ${PRUNE_RETENTION_DAYS} days`);
+            }
+        }
+        catch (err) {
+            console.error("[prune] Error during cleanup:", err);
+        }
+    }, PRUNE_INTERVAL_MS);
+    pruneTimer.unref();
+    // Run once on startup after a brief delay
+    const pruneStartup = setTimeout(() => {
+        try {
+            pruneOldScheduleRuns(PRUNE_RETENTION_DAYS);
+            pruneOldNotifications(PRUNE_RETENTION_DAYS);
+        }
+        catch { /* best effort */ }
+    }, 5000);
+    pruneStartup.unref?.();
     console.log("[io] IO is fully operational.");
     // Notify Telegram if restarting
     if (config.telegramEnabled && process.env.IO_RESTARTED === "1") {

package/dist/notify.js

@@ -0,0 +1,105 @@
+import { config } from "./config.js";
+import { insertNotification, } from "./store/notifications.js";
+const HEARTBEAT_PATTERNS = [
+    /^no active tasks?\.?$/i,
+    /^nothing to report\.?$/i,
+    /^all clear\.?$/i,
+    /^no updates?\.?$/i,
+    /^no changes?\.?$/i,
+    /^idle\.?$/i,
+    /^heartbeat\.?$/i,
+    /^ok\.?$/i,
+];
+export function isMeaningfulOutput(text) {
+    const trimmed = (text ?? "").trim();
+    if (trimmed.length < 20)
+        return false;
+    const firstLine = trimmed.split("\n").map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+    if (HEARTBEAT_PATTERNS.some((re) => re.test(firstLine)))
+        return false;
+    return true;
+}
+let telegramSender;
+let tuiSender;
+let sseBroadcaster;
+export function setTelegramSender(fn) {
+    telegramSender = fn;
+}
+export function setTuiSender(fn) {
+    tuiSender = fn;
+}
+export function setSseBroadcaster(fn) {
+    sseBroadcaster = fn;
+}
+export function _resetNotifySendersForTests() {
+    telegramSender = undefined;
+    tuiSender = undefined;
+    sseBroadcaster = undefined;
+}
+export async function notifyBackground(input) {
+    const dispatched = { telegram: false, tui: false, sse: false };
+    const text = (input.text ?? "").trim();
+    if (text.length === 0)
+        return { dispatched, skipped: "empty" };
+    const mode = config.backgroundNotifyMode ?? "meaningful";
+    if (mode === "off")
+        return { dispatched, skipped: "off" };
+    if (mode === "meaningful" && !isMeaningfulOutput(text)) {
+        return { dispatched, skipped: "not-meaningful" };
+    }
+    const { source, title } = input;
+    const sourceRefJson = JSON.stringify(stripType(source));
+    let row;
+    try {
+        row = insertNotification({
+            source_type: source.type,
+            source_ref: sourceRefJson === "{}" ? null : sourceRefJson,
+            title,
+            text,
+        });
+    }
+    catch (err) {
+        console.error("[notify] failed to persist notification:", err);
+        return { dispatched };
+    }
+    if (sseBroadcaster) {
+        try {
+            sseBroadcaster({
+                id: row.id,
+                source: { type: source.type, ...stripType(source) },
+                title,
+                text,
+                createdAt: row.created_at,
+            });
+            dispatched.sse = true;
+        }
+        catch (err) {
+            console.error("[notify] sse broadcast failed:", err);
+        }
+    }
+    if (tuiSender && (config.backgroundNotifyTui ?? true)) {
+        try {
+            tuiSender({ title, text });
+            dispatched.tui = true;
+        }
+        catch (err) {
+            console.error("[notify] tui send failed:", err);
+        }
+    }
+    if (telegramSender && (config.backgroundNotifyTelegram ?? true)) {
+        try {
+            await telegramSender({ title, text });
+            dispatched.telegram = true;
+        }
+        catch (err) {
+            console.error("[notify] telegram send failed:", err);
+        }
+    }
+    return { id: row.id, dispatched };
+}
+function stripType(s) {
+    const { type: _t, ...rest } = s;
+    void _t;
+    return rest;
+}
+//# sourceMappingURL=notify.js.map

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 (
@@ -115,6 +131,29 @@ SELECT agent_slug,
        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