heyio 0.6.0 → 0.8.0

package/dist/api/server.js

@@ -15,6 +15,7 @@ import { listSchedules, getSchedule, deleteSchedule, setScheduleEnabled } from "
 import { listIoSchedules, getIoSchedule, deleteIoSchedule, setIoScheduleEnabled } from "../store/io-schedules.js";
 import { runScheduleNow } from "../copilot/scheduler.js";
 import { runIoScheduleNow } from "../copilot/io-scheduler.js";
+import { listRecentNotifications, listUnreadNotifications, countUnreadNotifications, markNotificationRead, markAllNotificationsRead, } from "../store/notifications.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_DIST = path.resolve(__dirname, "../../web-dist");
 let messageHandler;
@@ -28,6 +29,12 @@ export function broadcastToSSE(text) {
         res.write(`data: ${payload}\n\n`);
     }
 }
+export function broadcastNotificationToSSE(payload) {
+    const data = JSON.stringify({ type: "notification", ...payload });
+    for (const res of sseConnections) {
+        res.write(`data: ${data}\n\n`);
+    }
+}
 export async function startApiServer() {
     const app = express();
     app.use(express.json());
@@ -192,7 +199,26 @@ export async function startApiServer() {
         const taskId = Array.isArray(req.params.taskId) ? req.params.taskId[0] : req.params.taskId;
         try {
             const events = getTaskEvents(taskId);
-            const activity = summarize(events);
+            let activity = summarize(events);
+            // Fallback: when in-memory events are gone (e.g. daemon restart),
+            // build a minimal entry from the persisted task result so the UI
+            // doesn't show "no activity" for tasks that actually ran. (#66)
+            if (activity.length === 0) {
+                const task = getTask(taskId);
+                if (task?.result) {
+                    activity = [{
+                            ts: task.completed_at ? new Date(task.completed_at).getTime() : Date.now(),
+                            kind: "outcome",
+                            icon: task.status === "failed" ? "\u274c" : task.status === "done" ? "\u2705" : "\ud83d\udccb",
+                            summary: task.status === "failed"
+                                ? "Task failed (activity log unavailable after restart)"
+                                : "Task completed (activity log unavailable after restart)",
+                            rawType: "task.result.fallback",
+                            detail: task.result,
+                            raw: { result: task.result, status: task.status },
+                        }];
+                }
+            }
             res.json({ taskId, activity });
         }
         catch (e) {
@@ -426,6 +452,69 @@ export async function startApiServer() {
             res.status(500).json({ error: (e instanceof Error ? e.message : String(e)) });
         }
     });
+    // Notifications endpoints
+    api.get("/notifications", (_req, res) => {
+        try {
+            const unreadOnly = _req.query.unread === "true";
+            const rows = unreadOnly
+                ? listUnreadNotifications()
+                : (() => {
+                    const rawLimit = _req.query.limit;
+                    const parsed = typeof rawLimit === "string" ? Number.parseInt(rawLimit, 10) : NaN;
+                    const limit = Number.isFinite(parsed) && parsed > 0 ? Math.min(parsed, 200) : 50;
+                    return listRecentNotifications(limit);
+                })();
+            const unreadCount = countUnreadNotifications();
+            const notifications = rows.map(({ id, title, text, created_at, read_at, source_type, source_ref }) => {
+                let source = { type: source_type };
+                if (source_ref) {
+                    try {
+                        const parsed = JSON.parse(source_ref);
+                        source = { type: source_type, ...parsed };
+                    }
+                    catch {
+                        // source_ref is not valid JSON — fall back to type-only
+                    }
+                }
+                return { id, title, text, created_at, read_at, source };
+            });
+            res.json({ notifications, unreadCount });
+        }
+        catch (e) {
+            console.error("Error listing notifications:", e);
+            res.status(500).json({ error: "Failed to list notifications" });
+        }
+    });
+    api.post("/notifications/read-all", (_req, res) => {
+        try {
+            const marked = markAllNotificationsRead();
+            res.json({ marked });
+        }
+        catch (e) {
+            console.error("Error marking all notifications read:", e);
+            res.status(500).json({ error: "Failed to mark notifications read" });
+        }
+    });
+    api.post("/notifications/:id/read", (req, res) => {
+        try {
+            const rawId = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            const id = Number.parseInt(rawId, 10);
+            if (Number.isNaN(id)) {
+                res.status(400).json({ error: "invalid id" });
+                return;
+            }
+            const found = markNotificationRead(id);
+            if (!found) {
+                res.status(404).json({ error: "notification not found" });
+                return;
+            }
+            res.json({ ok: true });
+        }
+        catch (e) {
+            console.error("Error marking notification read:", e);
+            res.status(500).json({ error: "Failed to mark notification read" });
+        }
+    });
     // Chat endpoints
     api.post("/message", async (req, res) => {
         const { text } = req.body;

package/dist/config.js

@@ -4,6 +4,9 @@ const DEFAULT_CONFIG = {
     telegramEnabled: false,
     selfEditEnabled: false,
     port: 3170,
+    backgroundNotifyMode: "meaningful",
+    backgroundNotifyTelegram: true,
+    backgroundNotifyTui: true,
 };
 function loadConfig() {
     mkdirSync(IO_HOME, { recursive: true });

package/dist/copilot/io-scheduler.js

@@ -6,6 +6,8 @@
 import { listIoSchedules, listDueIoSchedules, recordIoScheduleRun, setIoScheduleTimestamps, updateIoScheduleNextRun, } from "../store/io-schedules.js";
 import { sendToOrchestrator } from "./orchestrator.js";
 import { nextRun } from "./cron.js";
+import { notifyBackground } from "../notify.js";
+import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
 const TICK_MS = 30_000;
 let timer;
 const inFlight = new Set();
@@ -30,13 +32,34 @@ async function fireSchedule(schedule) {
     }
     recordIoScheduleRun(schedule.id, ranAt, nextIso);
     console.log(`[io] io-scheduler: firing schedule "${schedule.name}" (next run: ${nextIso ?? "never"})`);
+    const run = startScheduleRun({
+        schedule_type: "io",
+        schedule_id: schedule.id,
+        schedule_name: schedule.name,
+    });
     try {
-        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, () => {
-            // No-op: scheduled work is fire-and-forget; output is captured in
-            // the orchestrator's conversation log.
+        let buffer = "";
+        await sendToOrchestrator(buildPrompt(schedule), { type: "background" }, (text, done) => {
+            buffer += text;
+            if (done) {
+                void notifyBackground({
+                    source: {
+                        type: "io-schedule",
+                        scheduleId: schedule.id,
+                        scheduleName: schedule.name,
+                    },
+                    title: `IO schedule: ${schedule.name}`,
+                    text: buffer.trim(),
+                }).then((notifyResult) => {
+                    completeScheduleRun(run.id, notifyResult.id);
+                }).catch((err) => {
+                    failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
+                });
+            }
         });
     }
     catch (err) {
+        failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
         console.error(`[io] io-scheduler: failed to dispatch schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
     }
     finally {

package/dist/copilot/scheduler.js

@@ -14,6 +14,8 @@ import { listSchedules, listDueSchedules, recordScheduleRun, setScheduleTimestam
 import { getSquad } from "../store/squads.js";
 import { delegateToAgent } from "./agents.js";
 import { nextRun } from "./cron.js";
+import { notifyBackground } from "../notify.js";
+import { startScheduleRun, completeScheduleRun, failScheduleRun } from "../store/schedule-runs.js";
 const TICK_MS = 30_000;
 const AGENDA_BLOCKS = {
     triage: `**Triage**
@@ -70,12 +72,32 @@ async function fireSchedule(schedule) {
     recordScheduleRun(schedule.id, ranAt, nextIso);
     const prompt = buildStandupPrompt({ name: squad.name, slug: squad.slug, project_path: squad.project_path }, schedule);
     console.log(`[io] scheduler: firing schedule "${schedule.name}" for squad "${squad.slug}" (next run: ${nextIso ?? "never"})`);
+    const run = startScheduleRun({
+        schedule_type: "squad",
+        schedule_id: schedule.id,
+        schedule_name: schedule.name,
+        squad_slug: squad.slug,
+    });
     try {
-        await delegateToAgent(squad.slug, prompt, () => {
-            // No-op: result is recorded on the agent task; the standup is fire-and-forget.
+        await delegateToAgent(squad.slug, prompt, (_taskId, result) => {
+            void notifyBackground({
+                source: {
+                    type: "squad-schedule",
+                    scheduleId: schedule.id,
+                    squadSlug: squad.slug,
+                    scheduleName: schedule.name,
+                },
+                title: `${squad.name}: ${schedule.name}`,
+                text: result,
+            }).then((notifyResult) => {
+                completeScheduleRun(run.id, notifyResult.id);
+            }).catch((err) => {
+                failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
+            });
         });
     }
     catch (err) {
+        failScheduleRun(run.id, err instanceof Error ? err.message : String(err));
         console.error(`[io] scheduler: failed to delegate stand-up for schedule ${schedule.id}:`, err instanceof Error ? err.message : err);
     }
     finally {

package/dist/copilot/session-timeout.test.js

@@ -0,0 +1,372 @@
+/**
+ * Tests for src/copilot/session-timeout.ts — sendWithIdleTimeout
+ *
+ * Strategy: build a FakeSession class whose sendAndWait() is controlled by
+ * a deferred Promise. Event handlers registered via .on() are stored in a
+ * subscriber list and can be triggered manually with .emit(). Timer
+ * behaviour is driven by node:test's mock.timers so no real setTimeout fires.
+ */
+import { describe, it, before, after, beforeEach, mock } from "node:test";
+import assert from "node:assert/strict";
+import { sendWithIdleTimeout, } from "./session-timeout.js";
+/** Minimal fake implementing only what sendWithIdleTimeout needs. */
+function makeFakeSession() {
+    const broadcastHandlers = [];
+    const deltaHandlers = [];
+    let resolveWait;
+    let rejectWait;
+    let aborted = false;
+    const session = {
+        // Typed overload: session.on("assistant.message_delta", handler)
+        // Generic overload: session.on(handler)
+        on(typeOrHandler, handler) {
+            if (typeof typeOrHandler === "function") {
+                broadcastHandlers.push(typeOrHandler);
+                return () => {
+                    const idx = broadcastHandlers.indexOf(typeOrHandler);
+                    if (idx !== -1)
+                        broadcastHandlers.splice(idx, 1);
+                };
+            }
+            // typed: only care about delta for accumulation
+            if (typeOrHandler === "assistant.message_delta" && handler) {
+                deltaHandlers.push(handler);
+                return () => {
+                    const idx = deltaHandlers.indexOf(handler);
+                    if (idx !== -1)
+                        deltaHandlers.splice(idx, 1);
+                };
+            }
+            return () => { };
+        },
+        sendAndWait(_opts, _timeout) {
+            return new Promise((resolve, reject) => {
+                resolveWait = resolve;
+                rejectWait = reject;
+            });
+        },
+        abort() {
+            aborted = true;
+            return Promise.resolve();
+        },
+        // ── Test-only helpers ──────────────────────────────────────────────────
+        /** Emit an event to all broad-listener handlers. */
+        emit(event) {
+            for (const h of broadcastHandlers)
+                h(event);
+        },
+        /** Emit an assistant.message_delta event with the given text chunk. */
+        emitDelta(deltaContent) {
+            const deltaEvent = {
+                type: "assistant.message_delta",
+                id: "evt-1",
+                timestamp: new Date().toISOString(),
+                parentId: null,
+                ephemeral: true,
+                data: { messageId: "msg-1", deltaContent },
+            };
+            // Notify delta-specific handlers
+            for (const h of deltaHandlers) {
+                h(deltaEvent);
+            }
+            // Also broadcast to all-event handlers so idle timer resets
+            this.emit(deltaEvent);
+        },
+        /** Emit a generic progress event (e.g. tool.execution_complete). */
+        emitProgress(type) {
+            const event = {
+                type,
+                id: "evt-2",
+                timestamp: new Date().toISOString(),
+                parentId: null,
+                ephemeral: false,
+                data: {},
+            };
+            this.emit(event);
+        },
+        /** Resolve the sendAndWait promise with a final content string. */
+        resolve(content) {
+            resolveWait?.({ data: { content } });
+        },
+        /** Resolve the sendAndWait promise with undefined (triggers accumulated fallback). */
+        resolveUndefined() {
+            resolveWait?.(undefined);
+        },
+        /** Reject the sendAndWait promise with a timeout-style error. */
+        rejectWithTimeout() {
+            rejectWait?.(new Error("Timeout after 600000ms waiting for session.idle"));
+        },
+        /** Reject the sendAndWait promise with a non-timeout error. */
+        rejectWithError(msg) {
+            rejectWait?.(new Error(msg));
+        },
+        get wasAborted() {
+            return aborted;
+        },
+    };
+    return session;
+}
+// Cast FakeSession to CopilotSession for type-compatibility with sendWithIdleTimeout.
+// The fake satisfies the structural subset used by the function.
+function asSession(fake) {
+    return fake;
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+const DEFAULT_OPTS = {
+    idleMs: 5_000,
+    hardCapMs: 30_000,
+};
+// ── Tests ─────────────────────────────────────────────────────────────────────
+describe("sendWithIdleTimeout", () => {
+    before(() => {
+        mock.timers.enable({ apis: ["setTimeout"] });
+    });
+    after(() => {
+        mock.timers.reset();
+    });
+    beforeEach(() => {
+        // Reset the fake timer state between tests without disabling
+        mock.timers.reset();
+        mock.timers.enable({ apis: ["setTimeout"] });
+    });
+    // ── happy path ──────────────────────────────────────────────────────────
+    it("returns content and timedOut=false when session resolves normally", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "do something", DEFAULT_OPTS);
+        // Let the initial idle timer be registered, then resolve immediately
+        fake.resolve("task done successfully");
+        const result = await promise;
+        assert.equal(result.timedOut, false);
+        assert.equal(result.content, "task done successfully");
+        assert.equal(result.timeoutReason, undefined);
+    });
+    it("accumulates delta content during streaming (verified via resolveUndefined)", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "stream this", DEFAULT_OPTS);
+        fake.emitDelta("Hello ");
+        fake.emitDelta("world");
+        fake.emitDelta("!");
+        // resolveUndefined triggers `response?.data?.content ?? accumulated` → uses accumulated
+        fake.resolveUndefined();
+        const result = await promise;
+        assert.equal(result.timedOut, false);
+        assert.equal(result.content, "Hello world!");
+    });
+    it("falls back to accumulated delta when sendAndWait resolves with undefined", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "stream this", DEFAULT_OPTS);
+        fake.emitDelta("partial ");
+        fake.emitDelta("output");
+        // Resolve with undefined to trigger the `response?.data?.content ?? accumulated` fallback
+        fake.resolveUndefined();
+        const result = await promise;
+        assert.equal(result.timedOut, false);
+        assert.equal(result.content, "partial output");
+    });
+    // ── idle timer reset ────────────────────────────────────────────────────
+    it("resets idle timer on assistant.message_delta", async () => {
+        const fake = makeFakeSession();
+        const idleTimeoutFired = { value: false };
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 1_000,
+            onIdleTimeout: () => { idleTimeoutFired.value = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "do work", opts);
+        // Advance to just before idle timeout — timer should NOT fire yet
+        mock.timers.tick(800);
+        assert.equal(idleTimeoutFired.value, false);
+        // Emit a progress event — should reset the idle timer
+        fake.emitProgress("tool.execution_complete");
+        // Advance another 800ms — if reset worked, timer still hasn't fired (800 < 1000)
+        mock.timers.tick(800);
+        assert.equal(idleTimeoutFired.value, false, "idle timer should have been reset by progress event");
+        // Resolve and clean up
+        fake.resolve("done");
+        await promise;
+    });
+    it("fires idle timeout after idleMs of silence", async () => {
+        const fake = makeFakeSession();
+        let idleFired = false;
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 2_000,
+            onIdleTimeout: () => { idleFired = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "long task", opts);
+        // Advance past idle timeout — no events emitted
+        mock.timers.tick(2_001);
+        // Abort fires async; wait a tick then check
+        await Promise.resolve();
+        assert.equal(idleFired, true, "onIdleTimeout should have fired");
+        assert.equal(fake.wasAborted, true, "session.abort() should have been called");
+        // Simulate the sendAndWait timing out after abort
+        fake.rejectWithTimeout();
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+    });
+    it("resets idle timer on tool.execution_complete", async () => {
+        const fake = makeFakeSession();
+        let idleFired = false;
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 1_000,
+            onIdleTimeout: () => { idleFired = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "tool task", opts);
+        mock.timers.tick(700);
+        fake.emitProgress("tool.execution_complete");
+        mock.timers.tick(700); // 700ms since last reset — still under 1000ms
+        assert.equal(idleFired, false, "idle timer should have been reset by tool event");
+        fake.resolve("done");
+        await promise;
+        assert.equal(idleFired, false);
+    });
+    it("resets idle timer on assistant.turn_start", async () => {
+        const fake = makeFakeSession();
+        let idleFired = false;
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 1_000,
+            onIdleTimeout: () => { idleFired = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "turn task", opts);
+        mock.timers.tick(700);
+        fake.emitProgress("assistant.turn_start");
+        mock.timers.tick(700);
+        assert.equal(idleFired, false, "idle timer should reset on assistant.turn_start");
+        fake.resolve("done");
+        await promise;
+    });
+    it("does NOT reset idle timer for unrecognised event types", async () => {
+        const fake = makeFakeSession();
+        let idleFired = false;
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 1_000,
+            onIdleTimeout: () => { idleFired = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "noisy task", opts);
+        mock.timers.tick(700);
+        // This event type is not in PROGRESS_EVENT_TYPES
+        fake.emitProgress("some.unknown.event");
+        mock.timers.tick(400); // 700 + 400 = 1100ms since last real reset
+        await Promise.resolve();
+        assert.equal(idleFired, true, "idle timer should fire — unknown event should not reset it");
+        fake.rejectWithTimeout();
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+    });
+    // ── graceful timeout capture ─────────────────────────────────────────────
+    it("captures partial content when idle timeout fires mid-stream", async () => {
+        const fake = makeFakeSession();
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 1_000,
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "long output", opts);
+        // Agent emits some content then goes silent
+        fake.emitDelta("Step 1 done. ");
+        fake.emitDelta("Step 2 in progress...");
+        // Advance past idle timeout
+        mock.timers.tick(1_001);
+        await Promise.resolve();
+        // sendAndWait throws a timeout error after abort
+        fake.rejectWithTimeout();
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+        // idle timer fires first → abortReason="idle"; catch block sees aborted=true and preserves it
+        assert.equal(result.timeoutReason, "idle", "idle fired before sendAndWait rejection → reason stays idle");
+        assert.ok(result.content.includes("Step 1 done.") && result.content.includes("Step 2 in progress..."), `partial content should be captured; got: ${result.content}`);
+    });
+    it("returns fallback message when no content was accumulated before timeout", async () => {
+        const fake = makeFakeSession();
+        const opts = { ...DEFAULT_OPTS, idleMs: 500 };
+        const promise = sendWithIdleTimeout(asSession(fake), "silent agent", opts);
+        mock.timers.tick(501);
+        await Promise.resolve();
+        fake.rejectWithTimeout();
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+        assert.ok(result.content.includes("no output captured"), `should report no output captured; got: ${result.content}`);
+    });
+    it("sets timeoutReason=idle when abort fires before sendAndWait throws", async () => {
+        const fake = makeFakeSession();
+        let idleCallbackInfo;
+        const opts = {
+            ...DEFAULT_OPTS,
+            idleMs: 500,
+            onIdleTimeout: (info) => { idleCallbackInfo = info; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "silent", opts);
+        mock.timers.tick(501);
+        await Promise.resolve(); // let abort() fire
+        // When aborted=true, the resolve branch returns timedOut:true with timeoutReason from abortReason
+        fake.resolve("some final content");
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+        assert.equal(result.timeoutReason, "idle");
+        assert.ok(idleCallbackInfo, "onIdleTimeout callback should have been called");
+        assert.equal(idleCallbackInfo?.idleMs, 500);
+    });
+    it("calls onProgress for each recognised event type", async () => {
+        const fake = makeFakeSession();
+        const progressEvents = [];
+        const opts = {
+            ...DEFAULT_OPTS,
+            onProgress: (type) => progressEvents.push(type),
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "track progress", opts);
+        fake.emitProgress("tool.execution_start");
+        fake.emitProgress("tool.execution_complete");
+        fake.emitDelta("some output");
+        fake.resolve("done");
+        await promise;
+        assert.ok(progressEvents.includes("tool.execution_start"));
+        assert.ok(progressEvents.includes("tool.execution_complete"));
+        assert.ok(progressEvents.includes("assistant.message_delta"));
+    });
+    it("tracks lastEventType in result", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "track last", DEFAULT_OPTS);
+        fake.emitProgress("tool.execution_start");
+        fake.emitProgress("tool.execution_complete");
+        fake.resolve("done");
+        const result = await promise;
+        assert.equal(result.lastEventType, "tool.execution_complete");
+    });
+    // ── error handling ───────────────────────────────────────────────────────
+    it("re-throws non-timeout errors", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "bad prompt", DEFAULT_OPTS);
+        fake.rejectWithError("unexpected authentication failure");
+        await assert.rejects(() => promise, (err) => {
+            assert.ok(err.message.includes("unexpected authentication failure"));
+            return true;
+        });
+    });
+    it("calls onHardCap when sendAndWait throws timeout and aborted=false", async () => {
+        const fake = makeFakeSession();
+        let hardCapFired = false;
+        const opts = {
+            ...DEFAULT_OPTS,
+            onHardCap: () => { hardCapFired = true; },
+        };
+        const promise = sendWithIdleTimeout(asSession(fake), "hard task", opts);
+        // Don't advance past idle timer — just let the hard cap throw
+        fake.rejectWithTimeout();
+        const result = await promise;
+        assert.equal(result.timedOut, true);
+        assert.equal(result.timeoutReason, "hard_cap");
+        assert.equal(hardCapFired, true);
+    });
+    it("cleans up subscriptions after normal completion (no memory leak)", async () => {
+        const fake = makeFakeSession();
+        const promise = sendWithIdleTimeout(asSession(fake), "cleanup test", DEFAULT_OPTS);
+        fake.resolve("done");
+        const result = await promise;
+        assert.equal(result.timedOut, false);
+        // If unsubscribe threw, the test would fail — we're asserting no throw
+    });
+});
+//# sourceMappingURL=session-timeout.test.js.map