pulseed 0.1.5 → 0.2.0

package/dist/runtime/__tests__/daemon-runner.test.js

@@ -0,0 +1,1194 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { DaemonRunner } from "../daemon-runner.js";
+import { PIDManager } from "../pid-manager.js";
+import { Logger } from "../logger.js";
+import { makeTempDir } from "../../../tests/helpers/temp-dir.js";
+// ─── Helpers ───
+/**
+ * Poll until the given file path exists and contains valid JSON, or throw after timeout.
+ * Avoids relying on fixed setTimeout delays that are inherently flaky on loaded CI runners.
+ */
+async function pollForFile(filePath, timeoutMs = 2000, intervalMs = 20) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        try {
+            if (fs.existsSync(filePath)) {
+                return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+            }
+        }
+        catch {
+            // file not yet fully written — retry
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`Timed out waiting for file: ${filePath}`);
+}
+function makeLoopResult(overrides = {}) {
+    return {
+        goalId: "test-goal",
+        totalIterations: 1,
+        finalStatus: "completed",
+        iterations: [],
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        ...overrides,
+    };
+}
+function makeDeps(tmpDir, overrides = {}) {
+    const mockCoreLoop = {
+        run: vi.fn().mockResolvedValue(makeLoopResult()),
+        stop: vi.fn(),
+    };
+    const mockDriveSystem = {
+        shouldActivate: vi.fn().mockReturnValue(true),
+        getSchedule: vi.fn().mockResolvedValue(null),
+        prioritizeGoals: vi.fn().mockImplementation((ids) => ids),
+        startWatcher: vi.fn(),
+        stopWatcher: vi.fn(),
+    };
+    const mockStateManager = {
+        getBaseDir: vi.fn().mockReturnValue(tmpDir),
+    };
+    const pidManager = new PIDManager(tmpDir);
+    const logger = new Logger({
+        dir: path.join(tmpDir, "logs"),
+        consoleOutput: false,
+        level: "error",
+    });
+    return {
+        coreLoop: mockCoreLoop,
+        driveSystem: mockDriveSystem,
+        stateManager: mockStateManager,
+        pidManager,
+        logger,
+        ...overrides,
+    };
+}
+// ─── Test Suite ───
+describe("DaemonRunner", () => {
+    let tmpDir;
+    let currentDaemon = null;
+    let currentStartPromise = null;
+    beforeEach(() => {
+        tmpDir = makeTempDir();
+        currentDaemon = null;
+        currentStartPromise = null;
+    });
+    afterEach(async () => {
+        // Ensure any in-flight daemon is fully stopped before removing tmpDir.
+        // This prevents ENOENT races from writeJsonFileAtomic rename syscalls.
+        if (currentDaemon) {
+            currentDaemon.stop();
+            currentDaemon = null;
+        }
+        if (currentStartPromise) {
+            await currentStartPromise.catch(() => { });
+            currentStartPromise = null;
+        }
+        fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+        // Remove any process signal listeners that may have been registered
+        process.removeAllListeners("SIGINT");
+        process.removeAllListeners("SIGTERM");
+    });
+    // ─── Constructor / Config Defaults ───
+    describe("constructor", () => {
+        it("should construct without throwing with minimal deps", () => {
+            const deps = makeDeps(tmpDir);
+            expect(() => new DaemonRunner(deps)).not.toThrow();
+        });
+        it("should apply default config values (check_interval_ms = 300000)", () => {
+            // We test defaults indirectly through behavior; the daemon should not throw
+            const deps = makeDeps(tmpDir, { config: {} });
+            expect(() => new DaemonRunner(deps)).not.toThrow();
+        });
+        it("should accept partial config overrides", () => {
+            const deps = makeDeps(tmpDir, {
+                config: { check_interval_ms: 1000, crash_recovery: { max_retries: 1, enabled: true, retry_delay_ms: 500 } },
+            });
+            expect(() => new DaemonRunner(deps)).not.toThrow();
+        });
+    });
+    // ─── start() ───
+    describe("start()", () => {
+        it("should throw if daemon is already running (PID file from current process)", async () => {
+            const deps = makeDeps(tmpDir);
+            // Pre-write PID so isRunning() returns true
+            await deps.pidManager.writePID();
+            const daemon = new DaemonRunner(deps);
+            await expect(daemon.start(["goal-1"])).rejects.toThrow(/already running/i);
+            // Cleanup PID to allow afterEach cleanup to pass
+            await deps.pidManager.cleanup();
+        });
+        it("should write PID file on start", async () => {
+            const deps = makeDeps(tmpDir, {
+                config: { check_interval_ms: 50 },
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Let the loop run one iteration
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await startPromise;
+            // PID file should be cleaned up after stop
+            expect(await deps.pidManager.readPID()).toBeNull();
+        });
+        it("should save daemon-state.json with status=running on start", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = await pollForFile(statePath);
+            expect(state.status).toBe("running");
+            daemon.stop();
+            await startPromise;
+        });
+        it("should run CoreLoop.run() for active goals", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await startPromise;
+            expect(deps.coreLoop.run).toHaveBeenCalledWith("goal-1", { maxIterations: 10 });
+        });
+        it("should skip goals that shouldActivate returns false for", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await startPromise;
+            expect(deps.coreLoop.run).not.toHaveBeenCalled();
+        });
+        it("should pass active_goals to daemon state from start() argument", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-a", "goal-b"]);
+            currentStartPromise = startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = await pollForFile(statePath);
+            expect(state.active_goals).toEqual(["goal-a", "goal-b"]);
+            daemon.stop();
+            await startPromise;
+        });
+    });
+    // ─── stop() ───
+    describe("stop()", () => {
+        it("should set status to stopped in daemon-state.json after stop resolves", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 500 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            expect(["stopping", "stopped"]).toContain(state.status);
+        });
+        it("should terminate the loop and resolve the start() promise", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 30));
+            daemon.stop();
+            // Should resolve within a reasonable time
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+        it("should remove PID file after stopping", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 30));
+            daemon.stop();
+            await startPromise;
+            expect(await deps.pidManager.readPID()).toBeNull();
+        });
+        it("should set status to stopped in daemon-state.json after loop exits", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 30));
+            daemon.stop();
+            await startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            expect(state.status).toBe("stopped");
+        });
+    });
+    // ─── Error Handling / Crash Recovery ───
+    describe("error handling", () => {
+        it("should increment crash_count on loop error", async () => {
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    crash_recovery: { enabled: true, max_retries: 5, retry_delay_ms: 10 },
+                },
+            });
+            deps.coreLoop.run.mockRejectedValueOnce(new Error("simulated failure"));
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            expect(state.crash_count).toBeGreaterThanOrEqual(1);
+        });
+        it("should record last_error message on loop failure", async () => {
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    crash_recovery: { enabled: true, max_retries: 5, retry_delay_ms: 10 },
+                },
+            });
+            deps.coreLoop.run.mockRejectedValueOnce(new Error("boom!"));
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            // After 1 failure + stop, last_error may be null again if further runs succeeded.
+            // Check that crash_count recorded the failure.
+            expect(state.crash_count).toBeGreaterThanOrEqual(1);
+        });
+        it("should stop daemon when crash count reaches max_retries", async () => {
+            const maxRetries = 2;
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 10,
+                    crash_recovery: { enabled: true, max_retries: maxRetries, retry_delay_ms: 5 },
+                },
+            });
+            // Always fail
+            deps.coreLoop.run.mockRejectedValue(new Error("always fails"));
+            const daemon = new DaemonRunner(deps);
+            // start() should resolve on its own after max_retries exceeded
+            await daemon.start(["goal-1"]);
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            expect(state.crash_count).toBeGreaterThanOrEqual(maxRetries);
+        });
+        it("should set status to stopped (not crashed) when max_retries exceeded via handleLoopError", async () => {
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 10,
+                    crash_recovery: { enabled: true, max_retries: 2, retry_delay_ms: 5 },
+                },
+            });
+            deps.coreLoop.run.mockRejectedValue(new Error("always fails"));
+            const daemon = new DaemonRunner(deps);
+            await daemon.start(["goal-1"]);
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            // Status ends as "stopped" since cleanup() runs after the loop (not "crashed")
+            expect(state.status).toBe("stopped");
+        });
+    });
+    // ─── generateCronEntry (static) ───
+    describe("generateCronEntry()", () => {
+        it("should generate a sub-hourly cron entry for interval < 60 min", () => {
+            const entry = DaemonRunner.generateCronEntry("my-goal", 15);
+            expect(entry).toBe("*/15 * * * * /usr/bin/env pulseed run --goal my-goal");
+        });
+        it("should generate an hourly cron entry for interval = 60 min (1 hour)", () => {
+            const entry = DaemonRunner.generateCronEntry("my-goal", 60);
+            expect(entry).toBe("0 */1 * * * /usr/bin/env pulseed run --goal my-goal");
+        });
+        it("should generate a multi-hour cron entry for interval between 60 and 1440 min", () => {
+            const entry = DaemonRunner.generateCronEntry("my-goal", 240);
+            expect(entry).toBe("0 */4 * * * /usr/bin/env pulseed run --goal my-goal");
+        });
+        it("should generate a daily cron entry for interval >= 1440 min (1 day)", () => {
+            const entry = DaemonRunner.generateCronEntry("my-goal", 1440);
+            expect(entry).toBe("0 0 * * * /usr/bin/env pulseed run --goal my-goal");
+        });
+        it("should treat interval > 1440 as daily", () => {
+            const entry = DaemonRunner.generateCronEntry("my-goal", 2880);
+            expect(entry).toBe("0 0 * * * /usr/bin/env pulseed run --goal my-goal");
+        });
+        it("should use 60-minute default when no interval is provided", () => {
+            const entry = DaemonRunner.generateCronEntry("goal-default");
+            expect(entry).toBe("0 */1 * * * /usr/bin/env pulseed run --goal goal-default");
+        });
+        it("should treat interval <= 0 as 60 minutes", () => {
+            const entry0 = DaemonRunner.generateCronEntry("goal-x", 0);
+            const entryNeg = DaemonRunner.generateCronEntry("goal-x", -5);
+            expect(entry0).toBe("0 */1 * * * /usr/bin/env pulseed run --goal goal-x");
+            expect(entryNeg).toBe("0 */1 * * * /usr/bin/env pulseed run --goal goal-x");
+        });
+        it("should include the goalId verbatim in the cron entry", () => {
+            const goalId = "complex-goal-id_123";
+            const entry = DaemonRunner.generateCronEntry(goalId, 30);
+            expect(entry).toContain(goalId);
+        });
+        it("should generate correct entry for 30-minute interval", () => {
+            const entry = DaemonRunner.generateCronEntry("g", 30);
+            expect(entry).toBe("*/30 * * * * /usr/bin/env pulseed run --goal g");
+        });
+        it("should generate correct entry for 1-minute interval", () => {
+            const entry = DaemonRunner.generateCronEntry("g", 1);
+            expect(entry).toBe("*/1 * * * * /usr/bin/env pulseed run --goal g");
+        });
+        it("should throw for goalId containing spaces", () => {
+            expect(() => DaemonRunner.generateCronEntry("bad goal", 60)).toThrow(/Invalid goalId/);
+        });
+        it("should throw for goalId containing semicolons", () => {
+            expect(() => DaemonRunner.generateCronEntry("goal;rm -rf /", 60)).toThrow(/Invalid goalId/);
+        });
+        it("should throw for goalId containing newlines", () => {
+            expect(() => DaemonRunner.generateCronEntry("goal\nmalicious", 60)).toThrow(/Invalid goalId/);
+        });
+        it("should throw for goalId containing shell special characters", () => {
+            expect(() => DaemonRunner.generateCronEntry("goal$(evil)", 60)).toThrow(/Invalid goalId/);
+        });
+        it("should accept goalId with only alphanumeric, underscore, and hyphen", () => {
+            expect(() => DaemonRunner.generateCronEntry("goal-abc_123", 60)).not.toThrow();
+        });
+    });
+    // ─── Daemon State Persistence ───
+    describe("daemon state persistence", () => {
+        it("should write daemon-state.json to baseDir on start", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            expect(fs.existsSync(path.join(tmpDir, "daemon-state.json"))).toBe(true);
+            daemon.stop();
+            await startPromise;
+        });
+        it("should record loop_count increments for each successful run", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 20 } });
+            // Always resolve quickly so loop runs multiple times
+            deps.coreLoop.run.mockResolvedValue(makeLoopResult());
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Allow ~3 iterations at 20ms interval
+            await new Promise((resolve) => setTimeout(resolve, 100));
+            daemon.stop();
+            await startPromise;
+            const state = JSON.parse(fs.readFileSync(path.join(tmpDir, "daemon-state.json"), "utf-8"));
+            expect(state.loop_count).toBeGreaterThanOrEqual(1);
+        });
+        it("should have pid set to current process PID in saved state", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 10));
+            const state = JSON.parse(fs.readFileSync(path.join(tmpDir, "daemon-state.json"), "utf-8"));
+            expect(state.pid).toBe(process.pid);
+            daemon.stop();
+            await startPromise;
+        });
+    });
+    // ─── Goal Interval Overrides ───
+    describe("goal_intervals config", () => {
+        it("should use the minimum goal interval when goal_intervals override is provided", async () => {
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 300_000,
+                    goal_intervals: { "goal-fast": 10 },
+                },
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-fast"]);
+            currentStartPromise = startPromise;
+            // 10ms interval → loop should run within 100ms
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            expect(deps.coreLoop.run).toHaveBeenCalledWith("goal-fast", { maxIterations: 10 });
+        });
+    });
+    // ─── Graceful Shutdown ───
+    describe("graceful shutdown", () => {
+        it("should set shuttingDown flag on SIGTERM signal", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 500 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Wait for daemon to be running
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            // Emit SIGTERM to trigger the shutdown handler
+            process.emit("SIGTERM");
+            // Give the handler time to run
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            // Daemon should resolve because shuttingDown exits the loop
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+        it("should complete current loop before stopping", async () => {
+            let loopRunCount = 0;
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            deps.coreLoop.run.mockImplementation(async () => {
+                loopRunCount++;
+                // Simulate a loop that takes some time
+                await new Promise((resolve) => setTimeout(resolve, 10));
+                return makeLoopResult();
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Wait for one loop to start
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            // Stop the daemon — it should finish the current loop
+            daemon.stop();
+            await startPromise;
+            // At least one loop should have completed
+            expect(loopRunCount).toBeGreaterThanOrEqual(1);
+        });
+        it("should save interrupted_goals on shutdown", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-a", "goal-b"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            // interrupted_goals should contain the active goals that were running
+            expect(state.interrupted_goals).toBeDefined();
+            expect(Array.isArray(state.interrupted_goals)).toBe(true);
+        });
+        it("should timeout and force stop after graceful_shutdown_timeout_ms", async () => {
+            // Use a very short timeout to test the force-stop path
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 10,
+                    crash_recovery: {
+                        enabled: true,
+                        max_retries: 10,
+                        retry_delay_ms: 10,
+                        graceful_shutdown_timeout_ms: 50,
+                    },
+                },
+            });
+            // Make the loop hang indefinitely so graceful shutdown times out
+            let resolveLoop = null;
+            deps.coreLoop.run.mockImplementation(() => {
+                return new Promise((resolve) => {
+                    resolveLoop = () => resolve(makeLoopResult());
+                });
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Wait for the loop to start (hanging)
+            await new Promise((resolve) => setTimeout(resolve, 30));
+            // Emit SIGTERM — this sets shuttingDown=true and starts the timeout
+            process.emit("SIGTERM");
+            // The force-stop timer fires after 50ms and sets running=false
+            // which exits the loop even though the current iteration is stuck
+            // We also need to resolve the hanging loop for the test to complete
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            if (resolveLoop)
+                resolveLoop();
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+    });
+    // ─── State Restoration ───
+    describe("state restoration", () => {
+        it("should restore interrupted_goals from daemon-state.json on start", async () => {
+            // Write a pre-existing daemon-state.json with interrupted_goals
+            const savedState = {
+                pid: 99999,
+                started_at: new Date().toISOString(),
+                last_loop_at: null,
+                loop_count: 0,
+                active_goals: ["goal-prev"],
+                status: "stopped",
+                crash_count: 0,
+                last_error: null,
+                interrupted_goals: ["goal-prev"],
+            };
+            fs.writeFileSync(path.join(tmpDir, "daemon-state.json"), JSON.stringify(savedState), "utf-8");
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-new"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            // active_goals should include both the new goal and the restored goal
+            expect(state.active_goals).toContain("goal-new");
+            expect(state.active_goals).toContain("goal-prev");
+            daemon.stop();
+            await startPromise;
+        });
+        it("should merge interrupted_goals with new goalIds without duplicates", async () => {
+            // Write a pre-existing daemon-state.json with interrupted_goals that overlap
+            const savedState = {
+                pid: 99999,
+                started_at: new Date().toISOString(),
+                last_loop_at: null,
+                loop_count: 0,
+                active_goals: ["goal-a"],
+                status: "stopped",
+                crash_count: 0,
+                last_error: null,
+                interrupted_goals: ["goal-a", "goal-b"],
+            };
+            fs.writeFileSync(path.join(tmpDir, "daemon-state.json"), JSON.stringify(savedState), "utf-8");
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            // Start with goal-a (overlaps with interrupted_goals) and goal-c
+            const startPromise = daemon.start(["goal-a", "goal-c"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            const statePath = path.join(tmpDir, "daemon-state.json");
+            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+            // Should contain goal-a, goal-b, goal-c — no duplicates
+            expect(state.active_goals).toContain("goal-a");
+            expect(state.active_goals).toContain("goal-b");
+            expect(state.active_goals).toContain("goal-c");
+            // No duplicate goal-a
+            const goalACount = state.active_goals.filter((g) => g === "goal-a").length;
+            expect(goalACount).toBe(1);
+            daemon.stop();
+            await startPromise;
+        });
+    });
+    // ─── Cleanup ───
+    describe("cleanup after loop", () => {
+        it("should remove PID file on normal stop", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 30 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            expect(fs.existsSync(deps.pidManager.getPath())).toBe(false);
+        });
+        it("should not leave .tmp files behind after state persistence", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 30));
+            daemon.stop();
+            await startPromise;
+            const files = fs.readdirSync(tmpDir);
+            expect(files.some((f) => f.endsWith(".tmp"))).toBe(false);
+        });
+    });
+    // ─── Event-Driven Integration ───
+    describe("event-driven integration", () => {
+        function makeEventServerMock() {
+            return {
+                start: vi.fn().mockResolvedValue(undefined),
+                stop: vi.fn().mockResolvedValue(undefined),
+                isRunning: vi.fn().mockReturnValue(true),
+                getHost: vi.fn().mockReturnValue("127.0.0.1"),
+                getPort: vi.fn().mockReturnValue(41700),
+                startFileWatcher: vi.fn(),
+                stopFileWatcher: vi.fn(),
+            };
+        }
+        it("should start EventServer on daemon start if provided", async () => {
+            const eventServer = makeEventServerMock();
+            const deps = makeDeps(tmpDir, {
+                config: { check_interval_ms: 50 },
+                eventServer: eventServer,
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            expect(eventServer.start).toHaveBeenCalledOnce();
+        });
+        it("should stop EventServer on daemon stop", async () => {
+            const eventServer = makeEventServerMock();
+            const deps = makeDeps(tmpDir, {
+                config: { check_interval_ms: 50 },
+                eventServer: eventServer,
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            expect(eventServer.stop).toHaveBeenCalledOnce();
+        });
+        it("should start file watcher on daemon start", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const startWatcherSpy = vi.spyOn(deps.driveSystem, "startWatcher");
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            expect(startWatcherSpy).toHaveBeenCalledOnce();
+            // Callback should be a function
+            expect(typeof startWatcherSpy.mock.calls[0][0]).toBe("function");
+        });
+        it("should stop file watcher on daemon stop", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const stopWatcherSpy = vi.spyOn(deps.driveSystem, "stopWatcher");
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 20));
+            daemon.stop();
+            await startPromise;
+            expect(stopWatcherSpy).toHaveBeenCalledOnce();
+        });
+        it("should wake up from sleep when event is received", async () => {
+            // Use a very long sleep interval so the daemon will stay sleeping without event
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 5_000 } });
+            let capturedCallback = null;
+            deps.driveSystem.startWatcher = vi.fn((cb) => {
+                capturedCallback = cb;
+            });
+            deps.driveSystem.stopWatcher = vi.fn();
+            const runSpy = deps.coreLoop;
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            // Wait for one loop iteration to complete and daemon to enter the 5s sleep
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            const callCountBeforeEvent = runSpy.run.mock.calls.length;
+            // Simulate an event arriving while daemon is sleeping — should wake immediately
+            expect(capturedCallback).not.toBeNull();
+            capturedCallback({
+                type: "external",
+                source: "test",
+                timestamp: new Date().toISOString(),
+                data: {},
+            });
+            // Give the loop time to wake and start another iteration (much less than 5s)
+            await new Promise((resolve) => setTimeout(resolve, 150));
+            const callCountAfterEvent = runSpy.run.mock.calls.length;
+            expect(callCountAfterEvent).toBeGreaterThan(callCountBeforeEvent);
+            // Stop the daemon; abort the sleep so it exits quickly
+            daemon.stop();
+            capturedCallback({
+                type: "internal",
+                source: "test-stop",
+                timestamp: new Date().toISOString(),
+                data: {},
+            });
+            await startPromise;
+        }, 10_000);
+        it("should work without EventServer (optional dependency)", async () => {
+            // No eventServer provided — daemon should start and stop normally
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+    });
+    // ─── Proactive Tick ───
+    describe("proactive tick", () => {
+        function makeLLMClientMock(action, details = {}) {
+            const response = JSON.stringify({ action, details });
+            return {
+                sendMessage: vi.fn().mockResolvedValue({
+                    content: response,
+                    usage: { input_tokens: 10, output_tokens: 10 },
+                    stop_reason: "end_turn",
+                }),
+                parseJSON: vi.fn().mockReturnValue({ action, details }),
+            };
+        }
+        it("should fire proactive tick when no goals activated and interval elapsed", async () => {
+            const llmClient = makeLLMClientMock("sleep");
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0, // always eligible
+                },
+                llmClient: llmClient,
+            });
+            // No goals should activate
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            expect(llmClient.sendMessage).toHaveBeenCalled();
+        });
+        it("should NOT fire proactive tick when proactive_mode is false", async () => {
+            const llmClient = makeLLMClientMock("sleep");
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: false,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            expect(llmClient.sendMessage).not.toHaveBeenCalled();
+        });
+        it("should NOT fire proactive tick when interval has not elapsed", async () => {
+            const llmClient = makeLLMClientMock("sleep");
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 9_999_999, // far future
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            expect(llmClient.sendMessage).not.toHaveBeenCalled();
+        });
+        it("should fire proactive tick even when goals were activated", async () => {
+            // After Change 4: proactiveTick runs every cycle regardless of activeGoals.length
+            // so long-running goals do not block proactive actions indefinitely.
+            const llmClient = makeLLMClientMock("sleep");
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            // Goals DO activate
+            deps.driveSystem.shouldActivate.mockReturnValue(true);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            // proactiveTick now fires unconditionally when running=true
+            expect(llmClient.sendMessage).toHaveBeenCalled();
+        });
+        it("should catch LLM error in proactive tick and not crash the daemon", async () => {
+            const llmClient = {
+                sendMessage: vi.fn().mockRejectedValue(new Error("LLM timeout")),
+                parseJSON: vi.fn(),
+            };
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            // Daemon must resolve cleanly despite LLM error
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+        it("should log suggest_goal action from proactive tick", async () => {
+            const llmClient = makeLLMClientMock("suggest_goal", { title: "New goal", description: "Do something" });
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            expect(llmClient.sendMessage).toHaveBeenCalled();
+        });
+        it("should handle investigate action from proactive tick without crashing", async () => {
+            const llmClient = makeLLMClientMock("investigate", { what: "goal-1 stalled", why: "no progress" });
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+        it("should handle preemptive_check action from proactive tick without crashing", async () => {
+            const llmClient = makeLLMClientMock("preemptive_check", { goal_id: "goal-1" });
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            deps.driveSystem.shouldActivate.mockReturnValue(false);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await expect(startPromise).resolves.toBeUndefined();
+        });
+    });
+    // ─── Adaptive Sleep ───
+    describe("adaptive sleep", () => {
+        function makeDaemonWithAdaptiveSleep(overrides = {}) {
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 300_000,
+                    adaptive_sleep: {
+                        enabled: true,
+                        min_interval_ms: 60_000,
+                        max_interval_ms: 1_800_000,
+                        night_start_hour: 22,
+                        night_end_hour: 7,
+                        night_multiplier: 2.0,
+                        ...overrides,
+                    },
+                },
+            });
+            return new DaemonRunner(deps);
+        }
+        it("should return base interval unchanged when adaptive_sleep is disabled", () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 300_000 } });
+            const daemon = new DaemonRunner(deps);
+            const result = daemon.calculateAdaptiveInterval(300_000, 0, 0, 0);
+            expect(result).toBe(300_000);
+        });
+        it("should return base interval when enabled and all factors are neutral (daytime, low gap, no idle)", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=1.0, activity=1.0 → 300000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.3, 0);
+                expect(result).toBe(300_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply night multiplier when current hour is in night range (after midnight)", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 23; } // 23:00 within [22, 7)
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=2.0, urgency=1.0, activity=1.0 → 600000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.3, 0);
+                expect(result).toBe(600_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply night multiplier for early morning hours", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 3; } // 03:00 within [22, 7)
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=2.0, urgency=1.0, activity=1.0 → 600000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.3, 0);
+                expect(result).toBe(600_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should not apply night multiplier during daytime", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 14; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=1.0, activity=1.0 → 300000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.3, 0);
+                expect(result).toBe(300_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply 0.5 urgency factor for high gap score (>= 0.8)", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=0.5, activity=1.0 → 150000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.9, 0);
+                expect(result).toBe(150_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply 0.75 urgency factor for medium gap score (0.5 to 0.8)", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=0.75, activity=1.0 → 225000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.6, 0);
+                expect(result).toBe(225_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply 0.75 activity factor when goals were activated this cycle", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=1.0, activity=0.75 → 225000
+                const result = daemon.calculateAdaptiveInterval(300_000, 2, 0.3, 0);
+                expect(result).toBe(225_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should apply 1.5 activity factor after 5 or more consecutive idle cycles", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // timeOfDay=1.0, urgency=1.0, activity=1.5 → 450000
+                const result = daemon.calculateAdaptiveInterval(300_000, 0, 0.3, 5);
+                expect(result).toBe(450_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should clamp result to min_interval_ms when too small", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep({ min_interval_ms: 120_000 });
+                // 50000 * 1.0 * 0.5 * 0.75 = 18750 → clamped to 120000
+                const result = daemon.calculateAdaptiveInterval(50_000, 2, 0.9, 0);
+                expect(result).toBe(120_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should clamp result to max_interval_ms when too large", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 23; } // night: 2.0
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep({ max_interval_ms: 1_800_000 });
+                // 1000000 * 2.0 * 1.0 * 1.5 = 3000000 → clamped to 1800000
+                const result = daemon.calculateAdaptiveInterval(1_000_000, 0, 0.3, 10);
+                expect(result).toBe(1_800_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should multiply all factors correctly", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 23; } // night: 2.0
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // 400000 * 2.0 * 0.75 * 0.75 = 450000, within [60000, 1800000]
+                const result = daemon.calculateAdaptiveInterval(400_000, 1, 0.6, 0);
+                expect(result).toBe(450_000);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+        it("should return an integer result", () => {
+            const realDate = globalThis.Date;
+            const mockDate = class extends realDate {
+                getHours() { return 12; }
+            };
+            globalThis.Date = mockDate;
+            try {
+                const daemon = makeDaemonWithAdaptiveSleep();
+                // 100001 * 0.75 = 75000.75 → rounded to integer
+                const result = daemon.calculateAdaptiveInterval(100_001, 0, 0.6, 0);
+                expect(Number.isInteger(result)).toBe(true);
+            }
+            finally {
+                globalThis.Date = realDate;
+            }
+        });
+    });
+    // ─── iterations_per_cycle / per-cycle budget ───
+    describe("iterations_per_cycle", () => {
+        it("should call CoreLoop.run with { maxIterations: 10 } by default", async () => {
+            const deps = makeDeps(tmpDir, { config: { check_interval_ms: 50 } });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await startPromise;
+            const runMock = deps.coreLoop.run;
+            expect(runMock).toHaveBeenCalledWith("goal-1", { maxIterations: 10 });
+        });
+        it("should call CoreLoop.run with { maxIterations: N } when iterations_per_cycle is configured", async () => {
+            const iterationsPerCycle = 5;
+            const deps = makeDeps(tmpDir, {
+                config: { check_interval_ms: 50, iterations_per_cycle: iterationsPerCycle },
+            });
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 60));
+            daemon.stop();
+            await startPromise;
+            const runMock = deps.coreLoop.run;
+            expect(runMock).toHaveBeenCalledWith("goal-1", { maxIterations: iterationsPerCycle });
+        });
+        it("should fire proactiveTick even when activeGoals.length > 0", async () => {
+            // Verify that proactiveTick is not gated behind activeGoals.length === 0.
+            // We use a mock LLM client and confirm sendMessage is called while goals are active.
+            const llmClient = {
+                sendMessage: vi.fn().mockResolvedValue({
+                    content: JSON.stringify({ action: "sleep" }),
+                    usage: { input_tokens: 5, output_tokens: 5 },
+                    stop_reason: "end_turn",
+                }),
+                parseJSON: vi.fn().mockReturnValue({ action: "sleep" }),
+            };
+            const deps = makeDeps(tmpDir, {
+                config: {
+                    check_interval_ms: 50,
+                    proactive_mode: true,
+                    proactive_interval_ms: 0,
+                },
+                llmClient: llmClient,
+            });
+            // Goals activate — this is the condition that used to block proactiveTick
+            deps.driveSystem.shouldActivate.mockReturnValue(true);
+            const daemon = new DaemonRunner(deps);
+            currentDaemon = daemon;
+            const startPromise = daemon.start(["goal-1"]);
+            currentStartPromise = startPromise;
+            await new Promise((resolve) => setTimeout(resolve, 80));
+            daemon.stop();
+            await startPromise;
+            // LLM should have been called even though goals were active
+            expect(llmClient.sendMessage).toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=daemon-runner.test.js.map