@mclawnet/swarm 0.1.13 → 0.1.14

package/dist/__tests__/always-on-manager.test.js

@@ -0,0 +1,797 @@
+// AlwaysOnManager tests (M7.3).
+//
+// Covers the per-project scheduler lifecycle, recordActivity gate, ticksToday
+// persistence across "restart" (drop + new instance), pause gate, and
+// always-on.log rotation. The runnerFactory option lets us inject a fake
+// WorkCycleRunner so we never need a real SwarmCoordinator here.
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync, mkdirSync, readFileSync, writeFileSync, statSync, existsSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { projectRoot } from "@mclawnet/task";
+import { AlwaysOnManager } from "../always-on/always-on-manager.js";
+import { loadAlwaysOnConfig, saveAlwaysOnConfig, } from "../always-on/config.js";
+let home;
+let workDir;
+function localYMD(d) {
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, "0");
+    const day = String(d.getDate()).padStart(2, "0");
+    return `${y}-${m}-${day}`;
+}
+beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), "always-on-mgr-home-"));
+    workDir = mkdtempSync(join(tmpdir(), "always-on-mgr-wd-"));
+    mkdirSync(projectRoot(workDir, home), { recursive: true });
+});
+afterEach(() => {
+    rmSync(home, { recursive: true, force: true });
+    rmSync(workDir, { recursive: true, force: true });
+});
+/**
+ * Build a fake WorkCycleRunner that records calls and resolves quickly.
+ * We never need the real SwarmCoordinator for these tests.
+ */
+function makeFakeRunner() {
+    const counter = { runCalls: 0 };
+    const runner = {
+        run: async (input) => {
+            counter.runCalls += 1;
+            return {
+                cycleId: `cycle-${counter.runCalls}`,
+                swarmId: `m7-cycle-${counter.runCalls}`,
+                taskRef: { id: "t1", title: "test" },
+                status: "completed",
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            };
+        },
+    };
+    return { runner, get runCalls() { return counter.runCalls; } };
+}
+/** Build a manager with default options + injected fake runner. */
+function makeManager(opts) {
+    const fake = makeFakeRunner();
+    const mgr = new AlwaysOnManager({
+        home,
+        swarmCoordinator: {},
+        pickNextTask: opts.pickNextTask ?? (async () => null),
+        now: opts.now,
+        userActiveWindowMs: opts.userActiveWindowMs,
+        logRotateBytes: opts.logRotateBytes,
+        runnerFactory: () => fake.runner,
+    });
+    return { mgr, runCalls: () => fake.runCalls };
+}
+describe("AlwaysOnManager — lifecycle", () => {
+    it("start() with mode=off creates an entry but leaves the scheduler stopped", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "off", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(snap).not.toBeNull();
+        expect(snap.mode).toBe("off");
+        expect(snap.nextTickAt).toBeNull(); // stopped → no next tick
+        await mgr.disposeAll();
+    });
+    it("start() with mode=active arms the scheduler timer", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(snap.mode).toBe("active");
+        expect(snap.nextTickAt).not.toBeNull(); // scheduler armed
+        await mgr.disposeAll();
+    });
+    it("stop() drops the entry; snapshot returns null", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        await mgr.stop(workDir);
+        expect(mgr.snapshot(workDir)).toBeNull();
+    });
+    it("start() is idempotent — second call rebuilds without leaking timers", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(snap.mode).toBe("active");
+        await mgr.disposeAll();
+    });
+});
+describe("AlwaysOnManager — applyConfig + refreshFromDisk", () => {
+    it("applyConfig persists merged config and updates live scheduler mode", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "off", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const r = await mgr.applyConfig(workDir, { mode: "active" });
+        expect(r.config.mode).toBe("active");
+        expect(loadAlwaysOnConfig(workDir, home).mode).toBe("active");
+        expect(mgr.snapshot(workDir).mode).toBe("active");
+        await mgr.disposeAll();
+    });
+    it("applyConfig auto-boots when the project has never been started", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "off", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        // Note: no start() before applyConfig.
+        const r = await mgr.applyConfig(workDir, { mode: "active" });
+        expect(r.config.mode).toBe("active");
+        expect(mgr.snapshot(workDir)).not.toBeNull();
+        await mgr.disposeAll();
+    });
+    it("applyConfig handles pausedUntil:null to clear pause", async () => {
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: "2030-01-01T00:00:00Z",
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const r = await mgr.applyConfig(workDir, { pausedUntil: null });
+        expect(r.config.pausedUntil).toBeUndefined();
+        await mgr.disposeAll();
+    });
+    it("refreshFromDisk re-syncs scheduler after external config write", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "off", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        // Simulate the M7.2 handler having merged + saved already.
+        saveAlwaysOnConfig(workDir, home, { mode: "aggressive", dailyBudget: 5 });
+        await mgr.refreshFromDisk(workDir);
+        expect(mgr.snapshot(workDir).mode).toBe("aggressive");
+        await mgr.disposeAll();
+    });
+});
+describe("AlwaysOnManager — userActive gate", () => {
+    it("I3: recordActivity within window → next tick is gated by userActive", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const baseTime = Date.UTC(2026, 5, 5, 12, 0, 0);
+        let nowMs = baseTime;
+        const { mgr } = makeManager({
+            now: () => new Date(nowMs),
+            userActiveWindowMs: 30 * 60 * 1000,
+        });
+        await mgr.start(workDir);
+        // Activity 5 min ago — well within the 30 min window.
+        nowMs += 5 * 60 * 1000;
+        mgr.recordActivity();
+        // Drive a tick directly via the scheduler — the userActive gate should
+        // short-circuit before onFire is reached.
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        const last = mgr.snapshot(workDir).recentTicks.at(-1);
+        expect(last.decision).toBe("skipped");
+        const gateNames = last.gateBreakdown.map((g) => g.gate);
+        expect(gateNames).toContain("userActive");
+        const userActiveEntry = last.gateBreakdown.find((g) => g.gate === "userActive");
+        expect(userActiveEntry.decision.kind).toBe("skip");
+        await mgr.disposeAll();
+    });
+    it("I3: recordActivity outside the window → next tick fires", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const baseTime = Date.UTC(2026, 5, 5, 12, 0, 0);
+        let nowMs = baseTime;
+        let runCalls = 0;
+        const fakeRunner = {
+            run: async () => {
+                runCalls += 1;
+                return {
+                    cycleId: `c${runCalls}`, swarmId: `s${runCalls}`,
+                    taskRef: { id: "t1", title: "t" },
+                    status: "completed",
+                    startedAt: new Date().toISOString(),
+                    endedAt: new Date().toISOString(),
+                };
+            },
+        };
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            pickNextTask: async () => null,
+            now: () => new Date(nowMs),
+            userActiveWindowMs: 0, // disable the gate entirely
+            runnerFactory: () => fakeRunner,
+        });
+        await mgr.start(workDir);
+        mgr.recordActivity();
+        nowMs += 60_000;
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        expect(runCalls).toBe(1);
+        expect(mgr.snapshot(workDir).recentTicks.at(-1).decision).toBe("fired");
+        await mgr.disposeAll();
+    });
+    it("S1: recordActivity is per-project; activity on A does not gate B", async () => {
+        const workDirB = mkdtempSync(join(tmpdir(), "always-on-mgr-wd-b-"));
+        mkdirSync(projectRoot(workDirB, home), { recursive: true });
+        try {
+            saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+            saveAlwaysOnConfig(workDirB, home, { mode: "active", dailyBudget: 3 });
+            const baseTime = Date.UTC(2026, 5, 5, 12, 0, 0);
+            let nowMs = baseTime;
+            const { mgr } = makeManager({
+                now: () => new Date(nowMs),
+                userActiveWindowMs: 30 * 60 * 1000,
+            });
+            await mgr.start(workDir);
+            await mgr.start(workDirB);
+            // Activity only on project A.
+            nowMs += 60_000;
+            mgr.recordActivity(workDir);
+            const aEntry = mgr.entries.get(workDir);
+            const bEntry = mgr.entries.get(workDirB);
+            await aEntry.scheduler.tickNow();
+            await bEntry.scheduler.tickNow();
+            const aLast = mgr.snapshot(workDir).recentTicks.at(-1);
+            const bLast = mgr.snapshot(workDirB).recentTicks.at(-1);
+            expect(aLast.decision).toBe("skipped");
+            // B should NOT see userActive skip — no activity recorded for B.
+            const bUserActive = bLast.gateBreakdown.find((g) => g.gate === "userActive");
+            expect(bUserActive?.decision.kind).not.toBe("skip");
+            await mgr.disposeAll();
+        }
+        finally {
+            rmSync(workDirB, { recursive: true, force: true });
+        }
+    });
+    it("I3: pausedUntil in the future → tick is skipped at the pausedUntil gate", async () => {
+        const baseTime = Date.UTC(2026, 5, 5, 12, 0, 0);
+        let nowMs = baseTime;
+        const future = new Date(nowMs + 60 * 60 * 1000).toISOString();
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: future,
+        });
+        const { mgr } = makeManager({ now: () => new Date(nowMs) });
+        await mgr.start(workDir);
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        const last = mgr.snapshot(workDir).recentTicks.at(-1);
+        expect(last.decision).toBe("skipped");
+        const pausedEntry = last.gateBreakdown.find((g) => g.gate === "pausedUntil");
+        expect(pausedEntry.decision.kind).toBe("skip");
+        await mgr.disposeAll();
+    });
+    it("I3: pausedUntil in the past → falls through, tick can fire", async () => {
+        const baseTime = Date.UTC(2026, 5, 5, 12, 0, 0);
+        let nowMs = baseTime;
+        const past = new Date(nowMs - 60 * 60 * 1000).toISOString();
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: past,
+        });
+        const { mgr } = makeManager({ now: () => new Date(nowMs) });
+        await mgr.start(workDir);
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        const last = mgr.snapshot(workDir).recentTicks.at(-1);
+        // pausedUntil is past → fires (runner returns completed via fake).
+        expect(last.decision).toBe("fired");
+        await mgr.disposeAll();
+    });
+});
+describe("AlwaysOnManager — ticksToday persistence across restart", () => {
+    it("restoreState on start when ticksTodayDate matches today", async () => {
+        const today = localYMD(new Date());
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: 2,
+            ticksTodayDate: today,
+            lastFireAt: new Date().toISOString(),
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(snap.ticksToday).toBe(2);
+        expect(snap.lastFireAt).not.toBeNull();
+        await mgr.disposeAll();
+    });
+    it("resets ticksToday when persisted date is older than today", async () => {
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: 3,
+            ticksTodayDate: "2020-01-01",
+            lastFireAt: "2020-01-01T12:00:00.000Z",
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(snap.ticksToday).toBe(0); // reset
+        // lastFireAt is preserved for display (yesterday-at-noon UI hint).
+        expect(snap.lastFireAt).not.toBeNull();
+        await mgr.disposeAll();
+    });
+    it("survives a 'restart' (dispose + new manager + start)", async () => {
+        const today = localYMD(new Date());
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: 1,
+            ticksTodayDate: today,
+            lastFireAt: new Date().toISOString(),
+        });
+        const { mgr: mgr1 } = makeManager({});
+        await mgr1.start(workDir);
+        expect(mgr1.snapshot(workDir).ticksToday).toBe(1);
+        await mgr1.disposeAll();
+        // Pretend we crashed and rebooted with a brand-new manager instance.
+        const { mgr: mgr2 } = makeManager({});
+        await mgr2.start(workDir);
+        expect(mgr2.snapshot(workDir).ticksToday).toBe(1);
+        await mgr2.disposeAll();
+    });
+});
+describe("AlwaysOnManager — always-on.log", () => {
+    function logPath() {
+        return join(projectRoot(workDir, home), "always-on.log");
+    }
+    it("writes one jsonl line per tick (skipped recorded too)", async () => {
+        // Mode=active + tiny tickInterval — but DiscoveryScheduler doesn't expose
+        // tickInterval through AlwaysOnManager. Use the pausedUntil gate to
+        // force a skip on each tick via tickNow.
+        const future = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: future,
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        // We rely on tickNow via the scheduler — manager doesn't expose tickNow,
+        // so reach in through a typed any cast. Tests are allowed this.
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        await entry.scheduler.tickNow();
+        expect(existsSync(logPath())).toBe(true);
+        const lines = readFileSync(logPath(), "utf-8").trim().split("\n");
+        expect(lines).toHaveLength(2);
+        const parsed = JSON.parse(lines[0]);
+        expect(parsed.decision).toBe("skipped");
+        expect(parsed.gateBreakdown.at(-1).gate).toBe("pausedUntil");
+        await mgr.disposeAll();
+    });
+    it("rotates the log when it exceeds the byte cap", async () => {
+        const future = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: future,
+        });
+        // Tiny cap so one tick is enough to trigger rotation.
+        const { mgr } = makeManager({ logRotateBytes: 50 });
+        await mgr.start(workDir);
+        const entry = mgr.entries.get(workDir);
+        // First tick → writes line (file < cap → no rotation pre-write).
+        await entry.scheduler.tickNow();
+        // Second tick → file > cap → rotation kicks in BEFORE write.
+        await entry.scheduler.tickNow();
+        // Third tick → also rotates again (line2 might already be > cap).
+        await entry.scheduler.tickNow();
+        expect(existsSync(logPath() + ".1")).toBe(true);
+        const sizeAfter = statSync(logPath()).size;
+        // After rotation, the live file shouldn't be massive (cap ≈ 50 bytes).
+        expect(sizeAfter).toBeLessThan(1024);
+        await mgr.disposeAll();
+    });
+    it("B5: fired tick log line includes cycle meta (cycleId/swarmId/source/status)", async () => {
+        // Boot in active mode without pausedUntil so the gate cascade fires onFire.
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 5 });
+        const fakeRunner = {
+            run: async () => ({
+                cycleId: "cycle-b5",
+                swarmId: "swarm-b5",
+                taskRef: {
+                    id: "t1",
+                    title: "demo",
+                    sourceKind: "idea-todo",
+                },
+                status: "completed",
+                startedAt: new Date().toISOString(),
+                endedAt: new Date().toISOString(),
+            }),
+        };
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            pickNextTask: async () => null, // unused — runnerFactory supplies the fake
+            runnerFactory: () => fakeRunner,
+        });
+        await mgr.start(workDir);
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        const lines = readFileSync(logPath(), "utf-8").trim().split("\n");
+        expect(lines).toHaveLength(1);
+        const parsed = JSON.parse(lines[0]);
+        expect(parsed.decision).toBe("fired");
+        expect(parsed.cycle).toEqual({
+            cycleId: "cycle-b5",
+            cycleStatus: "completed",
+            swarmId: "swarm-b5",
+            source: "idea-todo",
+        });
+        // PR-B Sub-PR-B4: GC ran (no .worktrees/ in this tmp workDir → empty
+        // result {0,0,0}, but field IS present on fired ticks). PR-B follow-up
+        // dropped totalBytesBefore/After (see worktree-gc.ts doc comment).
+        expect(parsed.gc).toEqual({
+            scanned: 0,
+            removed: 0,
+            retained: 0,
+        });
+        await mgr.disposeAll();
+    });
+    it("B5: skipped tick log line has no cycle meta (onFire never ran)", async () => {
+        // pausedUntil future → gate cascade skips, onFire is not invoked.
+        const future = new Date(Date.now() + 60 * 60 * 1000).toISOString();
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            pausedUntil: future,
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        const parsed = JSON.parse(readFileSync(logPath(), "utf-8").trim());
+        expect(parsed.decision).toBe("skipped");
+        expect(parsed.cycle).toBeUndefined();
+        // PR-B Sub-PR-B4: skipped ticks don't run GC either — no `gc` field.
+        expect(parsed.gc).toBeUndefined();
+        await mgr.disposeAll();
+    });
+});
+describe("AlwaysOnManager — snapshot wire shape", () => {
+    it("serialises Date fields to ISO strings", async () => {
+        const today = localYMD(new Date());
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: 1,
+            ticksTodayDate: today,
+            lastFireAt: "2026-06-05T10:00:00.000Z",
+        });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        const snap = mgr.snapshot(workDir);
+        expect(typeof snap.lastFireAt).toBe("string");
+        expect(snap.lastFireAt).toBe("2026-06-05T10:00:00.000Z");
+        expect(typeof snap.nextTickAt).toBe("string"); // armed
+        expect(Array.isArray(snap.recentTicks)).toBe(true);
+        await mgr.disposeAll();
+    });
+});
+describe("AlwaysOnManager — disposeAll", () => {
+    it("stops every entry", async () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "active", dailyBudget: 3 });
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        await mgr.disposeAll();
+        expect(mgr.snapshot(workDir)).toBeNull();
+    });
+});
+describe("AlwaysOnManager — corrupt config (I4)", () => {
+    it("start() boots with defaults when always-on.json is malformed", async () => {
+        // Write garbage JSON — pre-hotfix the boot scanner couldn't tell this
+        // apart from "never touched" and silently dropped the project from the
+        // always-on rotation.
+        writeFileSync(join(projectRoot(workDir, home), "always-on.json"), "{not valid json");
+        // loadAlwaysOnConfig should still return defaults (no throw).
+        const cfg = loadAlwaysOnConfig(workDir, home);
+        expect(cfg.mode).toBe("off");
+        const { mgr } = makeManager({});
+        await mgr.start(workDir);
+        // Manager boots (snapshot is non-null) — corrupt config no longer eats
+        // the project silently.
+        expect(mgr.snapshot(workDir)).not.toBeNull();
+        await mgr.disposeAll();
+    });
+});
+describe("loadAlwaysOnConfig — M7.3 runtime fields", () => {
+    it("restores ticksToday + ticksTodayDate + lastFireAt when valid", () => {
+        writeFileSync(join(projectRoot(workDir, home), "always-on.json"), JSON.stringify({
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: 2,
+            ticksTodayDate: "2026-06-05",
+            lastFireAt: "2026-06-05T12:00:00.000Z",
+        }));
+        const cfg = loadAlwaysOnConfig(workDir, home);
+        expect(cfg.ticksToday).toBe(2);
+        expect(cfg.ticksTodayDate).toBe("2026-06-05");
+        expect(cfg.lastFireAt).toBe("2026-06-05T12:00:00.000Z");
+    });
+    it("drops bad runtime fields silently (negative ticksToday, malformed date)", () => {
+        writeFileSync(join(projectRoot(workDir, home), "always-on.json"), JSON.stringify({
+            mode: "active",
+            dailyBudget: 3,
+            ticksToday: -1,
+            ticksTodayDate: "yesterday",
+            lastFireAt: 12345,
+        }));
+        const cfg = loadAlwaysOnConfig(workDir, home);
+        expect(cfg.ticksToday).toBeUndefined();
+        expect(cfg.ticksTodayDate).toBeUndefined();
+        expect(cfg.lastFireAt).toBeUndefined();
+    });
+});
+describe("saveAlwaysOnConfig — M7.3 runtime fields", () => {
+    it("round-trips ticksToday/ticksTodayDate/lastFireAt", () => {
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 5,
+            ticksToday: 3,
+            ticksTodayDate: "2026-06-05",
+            lastFireAt: "2026-06-05T10:00:00.000Z",
+        });
+        const reloaded = loadAlwaysOnConfig(workDir, home);
+        expect(reloaded.ticksToday).toBe(3);
+        expect(reloaded.ticksTodayDate).toBe("2026-06-05");
+        expect(reloaded.lastFireAt).toBe("2026-06-05T10:00:00.000Z");
+    });
+    it("omits runtime fields from disk when not supplied", () => {
+        saveAlwaysOnConfig(workDir, home, { mode: "off", dailyBudget: 3 });
+        const raw = JSON.parse(readFileSync(join(projectRoot(workDir, home), "always-on.json"), "utf-8"));
+        expect("ticksToday" in raw).toBe(false);
+        expect("ticksTodayDate" in raw).toBe(false);
+        expect("lastFireAt" in raw).toBe(false);
+    });
+});
+// ── M8 hotfix C1 — taskSources toggle gates the cascade ────────────────
+describe("AlwaysOnManager — C1 taskSources filter", () => {
+    it("disables ideaResearch source per-project on the very next pick after PATCH", async () => {
+        // Build a cascade where idea-research is enabled by default but the
+        // user has flipped it off in always-on.json. The manager builds a
+        // CascadePicker with a filter that re-reads each project's
+        // always-on.json on every pick, so we should observe the disabled
+        // source NEVER getting called.
+        const researchPick = vi.fn(async () => null);
+        const taskStorePick = vi.fn(async () => null);
+        const sources = [
+            { name: "task-store", kind: "task-store", pick: taskStorePick },
+            { name: "idea-research", kind: "idea-research", pick: researchPick },
+        ];
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            taskSources: {
+                taskStore: true,
+                ideaTodo: true,
+                ideaResearch: false,
+                introspection: false,
+            },
+        });
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            taskSources: sources,
+            runnerFactory: () => ({
+                run: async () => ({
+                    cycleId: "c",
+                    swarmId: "s",
+                    taskRef: null,
+                    status: "skipped",
+                    startedAt: "",
+                    endedAt: "",
+                }),
+            }),
+        });
+        await mgr.start(workDir);
+        // Drive the picker directly. The manager exposes pickNextTask via the
+        // runner constructor closure; we exercise it through the cascade by
+        // calling the picker bound to the entry.
+        const internal = mgr;
+        await internal.pickNextTask(workDir);
+        expect(taskStorePick).toHaveBeenCalledTimes(1);
+        expect(researchPick).not.toHaveBeenCalled();
+        // Now the user toggles ideaResearch on — applyConfig persists it.
+        await mgr.applyConfig(workDir, {
+            taskSources: { ideaResearch: true },
+        });
+        // Next pick MUST consult ideaResearch (no manager rebuild, no restart).
+        await internal.pickNextTask(workDir);
+        expect(researchPick).toHaveBeenCalledTimes(1);
+        await mgr.disposeAll();
+    });
+    it("refreshFromDisk does not need to rebuild the cascade — filter reads disk fresh per pick", async () => {
+        // Write a config with introspection ON but the manager doesn't see
+        // the file yet. refreshFromDisk is a no-op for filter behaviour
+        // because the filter never caches; we just verify the next pick
+        // observes the disk change.
+        const introspectionPick = vi.fn(async () => null);
+        const sources = [
+            { name: "queen-introspection", kind: "queen-introspection", pick: introspectionPick },
+        ];
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            taskSources: { introspection: false },
+        });
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            taskSources: sources,
+            runnerFactory: () => ({
+                run: async () => ({
+                    cycleId: "c",
+                    swarmId: "s",
+                    taskRef: null,
+                    status: "skipped",
+                    startedAt: "",
+                    endedAt: "",
+                }),
+            }),
+        });
+        await mgr.start(workDir);
+        const internal = mgr;
+        await internal.pickNextTask(workDir);
+        expect(introspectionPick).not.toHaveBeenCalled();
+        // External edit (simulating UI write through M7.2 handler) + refresh.
+        const current = loadAlwaysOnConfig(workDir, home);
+        saveAlwaysOnConfig(workDir, home, {
+            ...current,
+            taskSources: { introspection: true },
+        });
+        await mgr.refreshFromDisk(workDir);
+        await internal.pickNextTask(workDir);
+        expect(introspectionPick).toHaveBeenCalledTimes(1);
+        await mgr.disposeAll();
+    });
+});
+// ── R3 I-B: drainPending bypasses the cascade-picker toggle ────────────
+describe("AlwaysOnManager — R3 I-B drainPending bypasses toggle filter", () => {
+    it("toggle flipped OFF mid-flight — next tick still reaps pending via drainPending (cascade pick is skipped)", async () => {
+        // Scenario: user enables introspection, IntrospectionSource spawns a
+        // fire-and-forget swarm (leaves pendingIntrospectionSwarmId behind).
+        // Before that swarm reaches terminal state, the user toggles
+        // introspection OFF. The cascade picker filter now skips
+        // IntrospectionSource.pick() entirely — pre-R3 that meant the source's
+        // own Step-0 drain never fired and the pending breadcrumb persisted
+        // forever. The drainPending hook fixes this: it runs every tick before
+        // the cascade, regardless of toggle state.
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            taskSources: { introspection: false }, // toggled OFF
+            pendingIntrospectionSwarmId: "stale-swarm-id",
+        });
+        const drainCalls = [];
+        const pickCalls = [];
+        const introspectionSource = {
+            name: "queen-introspection",
+            kind: "queen-introspection",
+            async pick(wd) {
+                pickCalls.push(wd);
+                return null;
+            },
+            async drainPending(wd) {
+                drainCalls.push(wd);
+                // Simulate the source ingesting the pending swarm: clear breadcrumb
+                // and call coord.complete/fail.
+                const cur = loadAlwaysOnConfig(wd, home);
+                saveAlwaysOnConfig(wd, home, {
+                    ...cur,
+                    pendingIntrospectionSwarmId: undefined,
+                });
+            },
+        };
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            taskSources: [introspectionSource],
+            runnerFactory: () => ({
+                run: async () => ({
+                    cycleId: "c",
+                    swarmId: "s",
+                    taskRef: null,
+                    status: "skipped",
+                    startedAt: "",
+                    endedAt: "",
+                }),
+            }),
+        });
+        await mgr.start(workDir);
+        // Drive a single tick — drainPending fires before the cascade picker.
+        const entry = mgr.entries.get(workDir);
+        await entry.scheduler.tickNow();
+        // Drain ran exactly once (pre-cascade); cascade pick was filtered out
+        // because the toggle is OFF.
+        expect(drainCalls).toEqual([workDir]);
+        expect(pickCalls).toEqual([]);
+        // Breadcrumb was cleared by the drain — proving the toggle-off path
+        // still reaped the in-flight swarm.
+        expect(loadAlwaysOnConfig(workDir, home).pendingIntrospectionSwarmId).toBeUndefined();
+        await mgr.disposeAll();
+    });
+    it("drainAllSources is public + idempotent — second call is a no-op once pending is cleared", async () => {
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            taskSources: { introspection: true },
+            pendingIntrospectionSwarmId: "stale-swarm-id",
+        });
+        let drainCount = 0;
+        const introspectionSource = {
+            name: "queen-introspection",
+            kind: "queen-introspection",
+            async pick() {
+                return null;
+            },
+            async drainPending(wd) {
+                drainCount += 1;
+                const cur = loadAlwaysOnConfig(wd, home);
+                if (cur.pendingIntrospectionSwarmId) {
+                    saveAlwaysOnConfig(wd, home, {
+                        ...cur,
+                        pendingIntrospectionSwarmId: undefined,
+                    });
+                }
+            },
+        };
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            taskSources: [introspectionSource],
+            runnerFactory: () => ({
+                run: async () => ({
+                    cycleId: "c",
+                    swarmId: "s",
+                    taskRef: null,
+                    status: "skipped",
+                    startedAt: "",
+                    endedAt: "",
+                }),
+            }),
+        });
+        await mgr.start(workDir);
+        await mgr.drainAllSources(workDir);
+        await mgr.drainAllSources(workDir);
+        expect(drainCount).toBe(2); // both calls invoked the hook
+        // But pending was cleared after the first one, so the second is a no-op
+        // from the source's POV (still reaches the source, just nothing to do).
+        expect(loadAlwaysOnConfig(workDir, home).pendingIntrospectionSwarmId).toBeUndefined();
+        await mgr.disposeAll();
+    });
+    it("drainAllSources swallows source-level errors — one source's bug does not break the tick", async () => {
+        saveAlwaysOnConfig(workDir, home, {
+            mode: "active",
+            dailyBudget: 3,
+            taskSources: { introspection: true },
+        });
+        const badSource = {
+            name: "queen-introspection",
+            kind: "queen-introspection",
+            async pick() {
+                return null;
+            },
+            async drainPending() {
+                throw new Error("source blew up during drain");
+            },
+        };
+        const mgr = new AlwaysOnManager({
+            home,
+            swarmCoordinator: {},
+            taskSources: [badSource],
+            runnerFactory: () => ({
+                run: async () => ({
+                    cycleId: "c",
+                    swarmId: "s",
+                    taskRef: null,
+                    status: "skipped",
+                    startedAt: "",
+                    endedAt: "",
+                }),
+            }),
+        });
+        await mgr.start(workDir);
+        // Must NOT throw.
+        await expect(mgr.drainAllSources(workDir)).resolves.toBeUndefined();
+        await mgr.disposeAll();
+    });
+});
+// suppress unused-import warnings while keeping the import for type-only usage
+void vi;
+//# sourceMappingURL=always-on-manager.test.js.map