heyio 0.6.0 → 0.9.0

package/dist/copilot/skills.js

@@ -1,6 +1,6 @@
-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 { execFileSync } from "child_process";
 import { SKILLS_DIR } from "../paths.js";
 /**
  * Scan SKILLS_DIR for subdirectories that contain a SKILL.md file.
@@ -80,28 +80,125 @@ 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) {
-    const repoName = basename(repoUrl, ".git").replace(/\.git$/, "");
-    const destDir = join(SKILLS_DIR, repoName);
-    execSync(`git clone ${repoUrl} ${destDir}`, { stdio: "pipe" });
-    const skillMdPath = join(destDir, "SKILL.md");
-    if (!existsSync(skillMdPath)) {
-        rmSync(destDir, { recursive: true, force: true });
-        throw new Error(`Repository "${repoUrl}" does not contain a SKILL.md file.`);
+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) };
     }
-    const content = readFileSync(skillMdPath, "utf-8");
+    if (GENERIC_SKILL_MD_RE.test(input)) {
+        if (!input.startsWith("https://")) {
+            throw new Error("Only https:// URLs are supported for SKILL.md installs.");
+        }
+        let urlObj;
+        try {
+            urlObj = new URL(input);
+        }
+        catch {
+            throw new Error(`Invalid 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 || repoName,
-        slug: repoName,
+        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) {
+    let destDir;
+    try {
+        const parsed = parseSkillUrl(input);
+        if (parsed.type === "file") {
+            return await installSkillFromFile(parsed.rawUrl, parsed.slug);
+        }
+        const repoUrl = parsed.url;
+        const repoName = basename(repoUrl, ".git").replace(/\.git$/, "");
+        if (!repoName) {
+            throw new Error("Could not determine skill name from URL.");
+        }
+        destDir = join(SKILLS_DIR, repoName);
+        execFileSync("git", ["clone", repoUrl, destDir], {
+            stdio: "pipe",
+            timeout: 60_000,
+        });
+        const skillMdPath = join(destDir, "SKILL.md");
+        if (!existsSync(skillMdPath)) {
+            rmSync(destDir, { recursive: true, force: true });
+            destDir = undefined;
+            throw new Error(`Repository "${repoUrl}" does not contain a SKILL.md file.`);
+        }
+        const content = readFileSync(skillMdPath, "utf-8");
+        const { name, description } = parseSkillMd(content);
+        return {
+            name: name || repoName,
+            slug: repoName,
+            description,
+            path: destDir,
+        };
+    }
+    catch (e) {
+        // Clean up partially-created directory on failure
+        if (destDir && existsSync(destDir)) {
+            rmSync(destDir, { recursive: true, force: true });
+        }
+        throw e instanceof Error ? e : new Error(String(e));
+    }
+}
 /**
  * Remove a skill directory by its slug. Returns true if it existed.
  */

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 {