pulseed 0.4.0 → 0.4.2

package/dist/runtime/daemon/runner.js

@@ -0,0 +1,875 @@
+import * as path from "node:path";
+import { EventServer } from "../event/server.js";
+import { DaemonConfigSchema, DaemonStateSchema } from "../../base/types/daemon.js";
+import { generateCronEntry } from "./signals.js";
+import { rotateDaemonLog, calculateAdaptiveInterval as calcAdaptiveInterval } from "./health.js";
+import { HttpChannelAdapter } from "../gateway/index.js";
+import { PulSeedEventSchema } from "../../base/types/drive.js";
+import { LoopSupervisor } from "../executor/index.js";
+import { ApprovalStore, OutboxStore, RuntimeHealthStore, createRuntimeStorePaths } from "../store/index.js";
+import { LeaderLockManager } from "../leader-lock-manager.js";
+import { GoalLeaseManager } from "../goal-lease-manager.js";
+import { JournalBackedQueue } from "../queue/journal-backed-queue.js";
+import { QueueClaimSweeper } from "../queue/queue-claim-sweeper.js";
+import { ApprovalBroker } from "../approval-broker.js";
+import { CommandDispatcher } from "../command-dispatcher.js";
+import { EventDispatcher } from "../event/dispatcher.js";
+import { RuntimeOwnershipCoordinator, } from "./runtime-ownership.js";
+import { ProcessShutdownCoordinator, startDaemonStatusHeartbeat, } from "./runner-lifecycle.js";
+import { checkCrashRecoveryMarker, cleanupDaemonRun, collectGoalCycleScheduleSnapshot, deleteShutdownMarkerFile, determineActiveGoalsForCycle, expireOldCronTasks, getMaxGapScoreForGoals, getNextIntervalForGoals, processCronTasksForDaemon, processScheduleEntriesForDaemon, readShutdownMarkerFile, restoreInterruptedGoals, runProactiveMaintenance, runSupervisorMaintenanceCycleForDaemon, saveDaemonStateFile, writeChatMessageEvent, writeShutdownMarkerFile, } from "./index.js";
+// Re-exports for callers that imported these from daemon-runner
+export { generateCronEntry } from "./signals.js";
+export { rotateDaemonLog, calculateAdaptiveInterval } from "./health.js";
+const RUNTIME_LEADER_LEASE_MS = 30_000;
+const RUNTIME_LEADER_HEARTBEAT_MS = 10_000;
+export class DaemonRunner {
+    coreLoop;
+    driveSystem;
+    stateManager;
+    pidManager;
+    logger;
+    config;
+    running = false;
+    shuttingDown = false;
+    state;
+    baseDir;
+    logDir;
+    logPath;
+    eventServer;
+    approvalFn;
+    sleepAbortController = null;
+    currentGoalIds = [];
+    currentLoopIndex = 0;
+    lastProactiveTickAt = 0;
+    llmClient;
+    reportingEngine;
+    cronScheduler;
+    scheduleEngine;
+    consecutiveIdleCycles = 0;
+    gateway;
+    supervisor = null;
+    cronScheduleInterval = null;
+    shutdownResolve = null;
+    shutdownCoordinator = null;
+    stopStatusHeartbeat = null;
+    deps;
+    runtimeRoot = null;
+    approvalStore = null;
+    outboxStore = null;
+    runtimeHealthStore = null;
+    leaderLockManager = null;
+    goalLeaseManager = null;
+    journalQueue = null;
+    queueClaimSweeper = null;
+    approvalBroker = null;
+    commandDispatcher = null;
+    eventDispatcher = null;
+    runtimeOwnership;
+    constructor(deps) {
+        this.deps = deps;
+        this.coreLoop = deps.coreLoop;
+        this.driveSystem = deps.driveSystem;
+        this.stateManager = deps.stateManager;
+        this.pidManager = deps.pidManager;
+        this.logger = deps.logger;
+        this.eventServer = deps.eventServer;
+        this.llmClient = deps.llmClient;
+        this.reportingEngine = deps.reportingEngine;
+        this.cronScheduler = deps.cronScheduler;
+        this.scheduleEngine = deps.scheduleEngine;
+        this.gateway = deps.gateway;
+        this.supervisor = deps.supervisor ?? null;
+        this.lastProactiveTickAt = Date.now();
+        // Parse config with defaults via DaemonConfigSchema.parse()
+        this.config = DaemonConfigSchema.parse(deps.config ?? {});
+        // Resolve base directory from stateManager
+        this.baseDir = this.stateManager.getBaseDir();
+        // Pre-compute log paths used by rotateLog
+        this.logDir = path.join(this.baseDir, this.config.log_dir);
+        this.logPath = path.join(this.logDir, "pulseed.log");
+        this.runtimeRoot = this.resolveRuntimeRoot();
+        const runtimePaths = createRuntimeStorePaths(this.runtimeRoot);
+        this.approvalStore = new ApprovalStore(runtimePaths);
+        this.outboxStore = new OutboxStore(runtimePaths);
+        this.runtimeHealthStore = new RuntimeHealthStore(runtimePaths);
+        this.leaderLockManager = new LeaderLockManager(this.runtimeRoot);
+        this.goalLeaseManager = new GoalLeaseManager(this.runtimeRoot);
+        this.approvalBroker = new ApprovalBroker({
+            store: this.approvalStore,
+            logger: this.logger,
+        });
+        this.journalQueue = new JournalBackedQueue({
+            journalPath: path.join(this.runtimeRoot, "queue.json"),
+        });
+        this.queueClaimSweeper = new QueueClaimSweeper({
+            queue: this.journalQueue,
+        });
+        this.runtimeOwnership = new RuntimeOwnershipCoordinator({
+            runtimeRoot: this.runtimeRoot,
+            logger: this.logger,
+            approvalStore: this.approvalStore,
+            outboxStore: this.outboxStore,
+            runtimeHealthStore: this.runtimeHealthStore,
+            leaderLockManager: this.leaderLockManager,
+            onLeadershipLost: (reason) => this.failRuntimeLeadership(reason),
+        });
+        // Initialize daemon state
+        this.state = DaemonStateSchema.parse({
+            pid: process.pid,
+            started_at: new Date().toISOString(),
+            last_loop_at: null,
+            loop_count: 0,
+            active_goals: [],
+            status: "stopped",
+            crash_count: 0,
+            last_error: null,
+        });
+    }
+    resolveRuntimeRoot() {
+        const configuredRoot = this.config.runtime_root;
+        if (!configuredRoot || configuredRoot.trim() === "") {
+            return path.join(this.baseDir, "runtime");
+        }
+        return path.isAbsolute(configuredRoot)
+            ? configuredRoot
+            : path.resolve(this.baseDir, configuredRoot);
+    }
+    // ─── Public API ───
+    /**
+     * Start daemon loop for given goals.
+     * Throws if daemon is already running.
+     */
+    async start(goalIds) {
+        let startupReady = false;
+        try {
+            // 2. Rotate log if needed, then check for crash recovery marker
+            await this.rotateLog();
+            await this.checkCrashRecovery();
+            await this.initializeRuntimeFoundation();
+            await this.acquireRuntimeLeadership();
+            // 2c. Start EventServer (always-on) and file watcher
+            if (!this.eventServer) {
+                const esPort = this.config.event_server_port ?? 41700;
+                this.eventServer = new EventServer(this.driveSystem, {
+                    port: esPort,
+                    stateManager: this.stateManager,
+                    outboxStore: this.outboxStore ?? undefined,
+                }, this.logger);
+            }
+            if (this.outboxStore) {
+                this.eventServer.setOutboxStore?.(this.outboxStore);
+            }
+            this.eventServer.setActiveWorkersProvider?.(() => {
+                const workers = this.supervisor?.getState().workers ?? [];
+                return workers
+                    .filter((worker) => worker.goalId !== null)
+                    .map((worker) => ({
+                    worker_id: worker.workerId,
+                    goal_id: worker.goalId,
+                    started_at: worker.startedAt,
+                    iterations: worker.iterations,
+                }));
+            });
+            if (this.approvalBroker) {
+                this.approvalBroker.setBroadcast((eventType, data) => {
+                    void this.eventServer?.broadcast?.(eventType, data);
+                });
+                this.eventServer.setApprovalBroker?.(this.approvalBroker);
+            }
+            this.eventServer.setCommandEnvelopeHook?.(async (envelope) => this.handleInboundEnvelope(envelope));
+            if (this.gateway) {
+                // Phase A: Route through Gateway → Envelope → writeEvent
+                const httpAdapter = new HttpChannelAdapter(this.eventServer);
+                this.gateway.registerAdapter(httpAdapter);
+                this.gateway.onEnvelope(async (envelope) => this.handleInboundEnvelope(envelope));
+                // Wire onHighPriority to abort sleep — done via the abortSleep() public method.
+                // Callers who construct buses should pass: onHighPriority: () => daemon.abortSleep()
+                // The daemon provides abortSleep() below for this purpose.
+                await this.gateway.start();
+                this.logger.info("Gateway started with HTTP adapter", { port: this.eventServer.getPort() });
+            }
+            else {
+                await this.eventServer.start();
+                this.eventServer.startFileWatcher();
+                this.logger.info("EventServer started", { port: this.eventServer.getPort() });
+            }
+            // Wire approval bridge if not already provided
+            if (!this.approvalFn && this.eventServer) {
+                const es = this.eventServer;
+                this.approvalFn = async (task) => {
+                    const goalId = String(task["goal_id"] ?? "unknown");
+                    const description = String(task["description"] ?? "");
+                    const action = String(task["action"] ?? "");
+                    const taskId = String(task["id"] ?? "");
+                    if (this.reportingEngine) {
+                        try {
+                            await this.reportingEngine.generateNotification("approval_required", {
+                                goalId,
+                                message: description || action || taskId || "Task approval required",
+                                details: [`task_id: ${taskId || "(none)"}`, `action: ${action || "(none)"}`].join("\n"),
+                            });
+                        }
+                        catch (err) {
+                            this.logger.warn("Approval notification dispatch failed", {
+                                goalId,
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                    }
+                    return es.requestApproval(goalId, {
+                        id: taskId,
+                        description,
+                        action,
+                    });
+                };
+            }
+            this.stopStatusHeartbeat = startDaemonStatusHeartbeat({
+                eventServer: this.eventServer,
+                getSnapshot: () => ({
+                    status: this.state.status,
+                    activeGoals: this.state.active_goals,
+                    loopCount: this.state.loop_count,
+                    startedAt: this.state.started_at,
+                }),
+            });
+            this.driveSystem.startWatcher((event) => this.onEventReceived(event));
+            this.shuttingDown = false;
+            const shutdownTimeout = this.config.crash_recovery.graceful_shutdown_timeout_ms ?? 30_000;
+            this.shutdownCoordinator = new ProcessShutdownCoordinator({
+                logger: this.logger,
+                gracefulShutdownTimeoutMs: shutdownTimeout,
+                onShutdown: () => this.beginGracefulShutdown(),
+                onForceStop: () => {
+                    this.running = false;
+                },
+            });
+            this.shutdownCoordinator.activate();
+            // 4. Restore state from previous interrupted run
+            const mergedGoalIds = await this.restoreState(goalIds);
+            // 5. Save initial daemon state
+            this.running = true;
+            this.currentGoalIds = mergedGoalIds;
+            this.currentLoopIndex = 0;
+            this.state = DaemonStateSchema.parse({
+                pid: process.pid,
+                started_at: new Date().toISOString(),
+                last_loop_at: null,
+                loop_count: 0,
+                active_goals: mergedGoalIds,
+                status: "running",
+                crash_count: 0,
+                last_error: null,
+            });
+            await this.saveDaemonState();
+            // 5b. Write "running" shutdown marker (crash detection on next startup)
+            await this.writeShutdownMarker({
+                goal_ids: mergedGoalIds,
+                loop_index: 0,
+                timestamp: new Date().toISOString(),
+                reason: "startup",
+                state: "running",
+            });
+            // 6. Log start
+            this.logger.info("Daemon started", {
+                pid: process.pid,
+                goals: mergedGoalIds,
+                check_interval_ms: this.config.check_interval_ms,
+            });
+            const sweepResult = this.queueClaimSweeper?.sweep();
+            if (sweepResult && (sweepResult.reclaimed > 0 || sweepResult.deadlettered > 0)) {
+                this.logger.info("Recovered stale runtime claims on startup", {
+                    reclaimed: sweepResult.reclaimed,
+                    deadlettered: sweepResult.deadlettered,
+                    expiredClaimTokens: sweepResult.expiredClaimTokens,
+                });
+            }
+            this.queueClaimSweeper?.start();
+            // 7. Create supervisor if not already provided.
+            if (!this.supervisor) {
+                const factory = this.deps.coreLoopFactory ?? (() => this.coreLoop);
+                this.supervisor = new LoopSupervisor({
+                    coreLoopFactory: factory,
+                    journalQueue: this.journalQueue,
+                    goalLeaseManager: this.goalLeaseManager,
+                    driveSystem: this.driveSystem,
+                    stateManager: this.stateManager,
+                    logger: this.logger,
+                    onGoalComplete: async (goalId, result) => this.handleGoalCompletion(goalId, result),
+                    onEscalation: (goalId, crashCount, lastError) => {
+                        this.logger.error(`Goal ${goalId} suspended after ${crashCount} crashes: ${lastError}`);
+                    },
+                }, { iterationsPerCycle: this.config.iterations_per_cycle });
+            }
+            if (!this.eventDispatcher) {
+                this.eventDispatcher = new EventDispatcher({
+                    journalQueue: this.journalQueue,
+                    logger: this.logger,
+                    onGoalActivate: async (goalId) => this.handleGoalStartCommand(goalId),
+                    onExternalEvent: async (event) => this.driveSystem.writeEvent(PulSeedEventSchema.parse(event)),
+                    onCronTaskDue: async (task) => this.handleCronTaskDue(task.id),
+                });
+            }
+            if (!this.commandDispatcher) {
+                this.commandDispatcher = new CommandDispatcher({
+                    journalQueue: this.journalQueue,
+                    logger: this.logger,
+                    onGoalStart: async (goalId) => this.handleGoalStartCommand(goalId),
+                    onGoalStop: async (goalId) => this.handleGoalStopCommand(goalId),
+                    onChatMessage: async (goalId, message) => this.handleChatMessageCommand(goalId, message),
+                    onApprovalResponse: async (goalId, requestId, approved) => this.handleApprovalResponseCommand(goalId, requestId, approved),
+                });
+            }
+            await this.saveRuntimeHealthSnapshot(this.supervisor
+                ? "execution_ownership_durable"
+                : "foundation_only", {
+                gateway: this.gateway || this.eventServer ? "ok" : "degraded",
+                queue: "ok",
+                leases: "ok",
+                approval: "ok",
+                outbox: "ok",
+                supervisor: this.supervisor ? "ok" : "degraded",
+            });
+            // 8. Run main loop — supervisor mode when supervisor is injected via deps,
+            //    fallback to sequential runLoop otherwise.
+            startupReady = true;
+            let cleanupHandled = false;
+            try {
+                await this.eventDispatcher?.start();
+                await this.commandDispatcher?.start();
+                if (this.supervisor) {
+                    // Supervisor handles goal execution; cron/schedule must also run in this mode.
+                    await this.supervisor.start(mergedGoalIds);
+                    const maintenanceIntervalMs = this.config.check_interval_ms;
+                    await this.runSupervisorMaintenanceCycle();
+                    this.cronScheduleInterval = setInterval(async () => {
+                        if (this.shuttingDown)
+                            return;
+                        await this.runSupervisorMaintenanceCycle();
+                    }, maintenanceIntervalMs);
+                    // Block until stop() is called.
+                    await new Promise((resolve) => {
+                        this.shutdownResolve = resolve;
+                        // If already stopped before we get here, resolve immediately.
+                        if (!this.running)
+                            resolve();
+                    });
+                }
+                else {
+                    // Fallback: sequential mode
+                    await this.runLoop();
+                    cleanupHandled = true;
+                }
+            }
+            finally {
+                this.queueClaimSweeper?.stop();
+                this.shutdownCoordinator?.dispose();
+                this.shutdownCoordinator = null;
+                this.stopStatusHeartbeat?.();
+                this.stopStatusHeartbeat = null;
+                if (this.cronScheduleInterval !== null) {
+                    clearInterval(this.cronScheduleInterval);
+                    this.cronScheduleInterval = null;
+                }
+                await this.supervisor?.shutdown();
+                await this.eventDispatcher?.shutdown();
+                await this.commandDispatcher?.shutdown();
+                this.driveSystem.stopWatcher();
+                if (this.gateway) {
+                    await this.gateway.stop();
+                    this.logger.info("Gateway stopped");
+                }
+                else if (this.eventServer) {
+                    this.eventServer.stopFileWatcher();
+                    await this.eventServer.stop();
+                    this.logger.info("EventServer stopped");
+                }
+                if (!cleanupHandled) {
+                    await this.cleanup();
+                }
+            }
+        }
+        catch (err) {
+            if (!startupReady) {
+                await this.releaseStartupOwnership();
+            }
+            throw err;
+        }
+    }
+    async initializeRuntimeFoundation() {
+        await this.runtimeOwnership.initializeFoundation();
+    }
+    async saveRuntimeHealthSnapshot(phase, components) {
+        await this.runtimeOwnership.saveRuntimeHealthSnapshot(phase, components);
+    }
+    async acquireRuntimeLeadership() {
+        await this.runtimeOwnership.acquireLeadership(RUNTIME_LEADER_LEASE_MS, RUNTIME_LEADER_HEARTBEAT_MS);
+    }
+    failRuntimeLeadership(reason) {
+        if (this.state.status === "crashed") {
+            return;
+        }
+        this.logger.error("Lost runtime leadership; stopping daemon", {
+            error: reason,
+        });
+        this.state.status = "crashed";
+        this.state.last_error = reason;
+        this.running = false;
+        this.shuttingDown = true;
+        this.shutdownResolve?.();
+        this.sleepAbortController?.abort();
+        void this.saveDaemonState();
+    }
+    async releaseStartupOwnership() {
+        await this.runtimeOwnership.releaseLeadership();
+    }
+    /** Expose approvalFn for callers (e.g. cmdStart) to wire into TaskLifecycle */
+    getApprovalFn() {
+        return this.approvalFn;
+    }
+    /**
+     * Abort the current sleep cycle immediately.
+     */
+    abortSleep() {
+        this.sleepAbortController?.abort();
+    }
+    /**
+     * Signal daemon to stop after current iteration completes.
+     * Saves interrupted_goals so they can be restored on next start.
+     */
+    stop() {
+        this.running = false;
+        this.shutdownResolve?.();
+        this.sleepAbortController?.abort();
+        this.state.status = "stopping";
+        // Save current active_goals as interrupted_goals for state restoration
+        this.state.interrupted_goals = [...this.state.active_goals];
+        // Do NOT persist here — cleanup() will save the final state after the loop exits.
+        // Calling saveDaemonState() here would race with cleanup()'s save and corrupt the file.
+        this.logger.info("Stop requested — daemon will stop after current iteration");
+    }
+    // ─── Private: Main Loop ───
+    /**
+     * Main daemon loop. Runs until this.running is false or a critical error occurs.
+     */
+    async runLoop() {
+        while (this.running && !this.shuttingDown) {
+            try {
+                const goalIds = [...this.currentGoalIds];
+                const cycleSnapshot = await this.collectGoalCycleSnapshot(goalIds);
+                // 1. Determine which goals need activation
+                const activeGoals = await this.determineActiveGoals(goalIds, cycleSnapshot);
+                if (activeGoals.length === 0) {
+                    this.logger.info("No goals need activation this cycle", {
+                        checked: goalIds.length,
+                    });
+                }
+                // 2. Execute loop for each active goal
+                for (const goalId of activeGoals) {
+                    if (!this.running)
+                        break;
+                    this.logger.info(`Running loop for goal: ${goalId}`);
+                    try {
+                        const iterationsPerCycle = this.config.iterations_per_cycle ?? 1;
+                        const result = await this.coreLoop.run(goalId, { maxIterations: iterationsPerCycle });
+                        this.state.loop_count++;
+                        this.currentLoopIndex = this.state.loop_count;
+                        this.state.last_loop_at = new Date().toISOString();
+                        this.logger.info(`Loop completed for goal: ${goalId}`, {
+                            status: result.finalStatus,
+                            iterations: result.totalIterations,
+                        });
+                        if (this.eventServer) {
+                            const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+                            void this.eventServer.broadcast?.("iteration_complete", {
+                                goalId,
+                                loopCount: this.state.loop_count,
+                                status: goal?.status ?? "unknown",
+                            });
+                        }
+                    }
+                    catch (err) {
+                        this.handleLoopError(goalId, err);
+                    }
+                    // Bail out of goal iteration if crash limit exceeded
+                    if (!this.running)
+                        break;
+                }
+                // 3. Save state
+                await this.saveDaemonState();
+                if (this.eventServer) {
+                    void this.eventServer.broadcast?.("daemon_status", {
+                        status: this.state.status,
+                        activeGoals: this.state.active_goals,
+                        loopCount: this.state.loop_count,
+                        lastLoopAt: this.state.last_loop_at,
+                    });
+                }
+                // 3b. Process due cron-scheduled tasks
+                await this.processCronTasks();
+                // 3b2. Process schedule engine entries
+                await this.processScheduleEntries();
+                // 3c. Expire old cron tasks periodically (every 100 cycles)
+                if (this.state.loop_count > 0 && this.state.loop_count % 100 === 0) {
+                    await this.expireCronTasks();
+                }
+                // 4. Proactive tick: fire every cycle (not only when idle) so long-running goals
+                // do not block proactive actions indefinitely.
+                if (this.running) {
+                    await this.proactiveTick();
+                }
+                // 5. Track idle cycles for adaptive sleep
+                if (activeGoals.length > 0) {
+                    this.consecutiveIdleCycles = 0;
+                }
+                else {
+                    this.consecutiveIdleCycles++;
+                }
+                // 6. Wait for next check interval
+                if (this.running) {
+                    const baseIntervalMs = this.getNextInterval(goalIds);
+                    const maxGapScore = await this.getMaxGapScore(goalIds, cycleSnapshot);
+                    const intervalMs = this.calculateAdaptiveInterval(baseIntervalMs, activeGoals.length, maxGapScore, this.consecutiveIdleCycles);
+                    this.logger.info(`Sleeping for ${intervalMs}ms until next check`);
+                    await this.sleep(intervalMs);
+                }
+            }
+            catch (err) {
+                await this.handleCriticalError(err);
+            }
+        }
+        // Cleanup after loop exits
+        await this.cleanup();
+    }
+    // ─── Private: Goal Activation ───
+    /**
+     * Determine which goals should be activated this cycle.
+     * Uses DriveSystem.shouldActivate() for each goal, then sorts by priority.
+     */
+    async determineActiveGoals(goalIds, snapshot) {
+        return determineActiveGoalsForCycle(this.driveSystem, goalIds, snapshot);
+    }
+    async collectGoalCycleSnapshot(goalIds) {
+        return collectGoalCycleScheduleSnapshot(this.driveSystem, goalIds);
+    }
+    // ─── Private: Interval Calculation ───
+    /**
+     * Calculate the next check interval in milliseconds.
+     * Uses per-goal override from config.goal_intervals if configured,
+     * otherwise falls back to config.check_interval_ms.
+     * Returns the minimum interval across all goals (so the daemon checks
+     * as soon as the earliest goal is due).
+     */
+    getNextInterval(goalIds) {
+        return getNextIntervalForGoals(this.config, goalIds);
+    }
+    // ─── Private: Error Handling ───
+    /**
+     * Handle a non-critical loop error for a single goal.
+     * Increments crash_count and stops daemon if max_retries exceeded.
+     */
+    handleLoopError(goalId, err) {
+        this.state.last_error = err instanceof Error ? err.message : String(err);
+        this.state.crash_count++;
+        this.logger.error(`Loop error for goal ${goalId}`, {
+            error: this.state.last_error,
+            crash_count: this.state.crash_count,
+            max_retries: this.config.crash_recovery.max_retries,
+        });
+        // If crash count exceeds max_retries, stop daemon
+        if (this.state.crash_count >= this.config.crash_recovery.max_retries) {
+            this.logger.error(`Max crash retries (${this.config.crash_recovery.max_retries}) exceeded, stopping daemon`);
+            this.running = false;
+        }
+    }
+    /**
+     * Handle a critical daemon-level error (outer loop catch).
+     * Marks state as crashed and stops the loop.
+     */
+    async handleCriticalError(err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        this.logger.error("Critical daemon error", { error: msg });
+        this.state.status = "crashed";
+        this.state.last_error = msg;
+        await this.saveDaemonState();
+        this.running = false;
+    }
+    // ─── Private: State Persistence ───
+    /**
+     * Save daemon state to {baseDir}/daemon-state.json atomically.
+     */
+    async saveDaemonState() {
+        await saveDaemonStateFile(this.baseDir, this.state, this.logger);
+    }
+    /**
+     * Restore state from a previous interrupted run.
+     * Merges interrupted_goals from daemon-state.json with the given goalIds (deduped).
+     * Returns the merged goal ID array.
+     */
+    async restoreState(goalIds) {
+        return restoreInterruptedGoals(this.baseDir, goalIds, this.logger);
+    }
+    // ─── Private: Cleanup ───
+    /**
+     * Perform cleanup after the loop exits and write the final runtime health snapshot.
+     * Also writes "clean_shutdown" marker to enable crash-vs-clean detection on next startup.
+     */
+    async cleanup() {
+        await cleanupDaemonRun({
+            baseDir: this.baseDir,
+            state: this.state,
+            currentGoalIds: this.currentGoalIds,
+            currentLoopIndex: this.currentLoopIndex,
+            runtimeOwnership: this.runtimeOwnership,
+            logger: this.logger,
+        });
+    }
+    beginGracefulShutdown() {
+        if (this.shuttingDown) {
+            return;
+        }
+        this.shuttingDown = true;
+        this.logger.info("Shutting down gracefully...");
+        this.running = false;
+        this.state.status = "stopping";
+        this.state.interrupted_goals = [...this.state.active_goals];
+        this.shutdownResolve?.();
+        this.sleepAbortController?.abort();
+    }
+    // ─── Private: Cron Scheduler ───
+    /**
+     * Process due cron-scheduled tasks.
+     * Logs each task, executes based on type, and marks as fired.
+     */
+    async processCronTasks() {
+        await processCronTasksForDaemon({
+            cronScheduler: this.cronScheduler,
+            logger: this.logger,
+            acceptRuntimeEnvelope: (envelope) => this.acceptRuntimeEnvelope(envelope),
+        });
+    }
+    /**
+     * Process due schedule engine entries.
+     */
+    async processScheduleEntries() {
+        await processScheduleEntriesForDaemon({
+            scheduleEngine: this.scheduleEngine,
+            logger: this.logger,
+            acceptRuntimeEnvelope: (envelope) => this.acceptRuntimeEnvelope(envelope),
+        });
+    }
+    /**
+     * Expire old non-permanent cron tasks.
+     */
+    async expireCronTasks() {
+        await expireOldCronTasks(this.cronScheduler, this.logger);
+    }
+    // ─── Private: Sleep ───
+    /**
+     * Sleep for the given number of milliseconds.
+     * Can be aborted early via sleepAbortController (e.g. when an event arrives).
+     */
+    sleep(ms) {
+        this.sleepAbortController = new AbortController();
+        const abortController = this.sleepAbortController;
+        return new Promise((resolve) => {
+            const timer = setTimeout(resolve, ms);
+            abortController.signal.addEventListener("abort", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        }).finally(() => {
+            this.sleepAbortController = null;
+        });
+    }
+    // ─── Private: Event Handling ───
+    /**
+     * Called when a file-watcher event arrives from DriveSystem.
+     * Aborts the current sleep so the loop runs immediately.
+     */
+    onEventReceived(event) {
+        this.logger.info("Event received, triggering immediate loop", {
+            event_type: event.type,
+        });
+        this.sleepAbortController?.abort();
+    }
+    acceptRuntimeEnvelope(envelope) {
+        if (!this.journalQueue)
+            return true;
+        const result = this.journalQueue.accept(envelope);
+        if (result.accepted) {
+            return true;
+        }
+        this.logger.info("Runtime journal skipped envelope", {
+            id: envelope.id,
+            name: envelope.name,
+            type: envelope.type,
+            duplicate: result.duplicate,
+            runtime_root: this.runtimeRoot,
+        });
+        return false;
+    }
+    async handleInboundEnvelope(envelope) {
+        if (!this.acceptRuntimeEnvelope(envelope)) {
+            return;
+        }
+    }
+    async handleGoalStartCommand(goalId) {
+        if (!this.currentGoalIds.includes(goalId)) {
+            this.currentGoalIds.push(goalId);
+        }
+        this.state.active_goals = [...this.currentGoalIds];
+        await this.saveDaemonState();
+        this.supervisor?.activateGoal(goalId);
+        this.abortSleep();
+    }
+    async handleGoalStopCommand(goalId) {
+        this.currentGoalIds = this.currentGoalIds.filter((id) => id !== goalId);
+        this.state.active_goals = [...this.currentGoalIds];
+        if (this.state.interrupted_goals) {
+            this.state.interrupted_goals = this.state.interrupted_goals.filter((id) => id !== goalId);
+        }
+        await this.saveDaemonState();
+        this.supervisor?.deactivateGoal(goalId);
+        this.abortSleep();
+    }
+    async handleGoalCompletion(goalId, result) {
+        this.state.loop_count++;
+        this.currentLoopIndex = this.state.loop_count;
+        this.state.last_loop_at = new Date().toISOString();
+        await this.saveDaemonState();
+        if (this.eventServer) {
+            const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+            void this.eventServer.broadcast?.("iteration_complete", {
+                goalId,
+                loopCount: this.state.loop_count,
+                status: goal?.status ?? result.status,
+                iterations: result.totalIterations,
+            });
+            void this.eventServer.broadcast?.("daemon_status", {
+                status: this.state.status,
+                activeGoals: this.state.active_goals,
+                loopCount: this.state.loop_count,
+                lastLoopAt: this.state.last_loop_at,
+            });
+        }
+    }
+    async runSupervisorMaintenanceCycle() {
+        await runSupervisorMaintenanceCycleForDaemon({
+            currentGoalIds: this.currentGoalIds,
+            driveSystem: this.driveSystem,
+            supervisor: this.supervisor,
+            processCronTasks: () => this.processCronTasks(),
+            processScheduleEntries: () => this.processScheduleEntries(),
+            proactiveTick: () => this.proactiveTick(),
+            saveDaemonState: () => this.saveDaemonState(),
+            eventServer: this.eventServer,
+            state: this.state,
+        });
+    }
+    async handleChatMessageCommand(goalId, message) {
+        await writeChatMessageEvent(this.driveSystem, goalId, message);
+        this.abortSleep();
+    }
+    async handleApprovalResponseCommand(goalId, requestId, approved) {
+        if (this.approvalBroker) {
+            await this.approvalBroker.resolveApproval(requestId, approved, "dispatcher");
+            return;
+        }
+        if (goalId && this.eventServer) {
+            await this.eventServer.resolveApproval(requestId, approved);
+        }
+    }
+    async handleCronTaskDue(taskId) {
+        if (!this.cronScheduler) {
+            return;
+        }
+        try {
+            await this.cronScheduler.markFired(taskId);
+            this.logger.info(`Cron task fired: ${taskId}`);
+        }
+        catch (err) {
+            this.logger.warn(`Cron task ${taskId} failed`, {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            await this.cronScheduler.markFired(taskId);
+        }
+    }
+    // ─── Private: Proactive Tick ───
+    /**
+     * Ask the LLM for a proactive action when no goals were activated this cycle.
+     * Fires only if proactive_mode is enabled and enough time has passed since last tick.
+     * Errors are caught and logged — they never affect the daemon loop.
+     */
+    async proactiveTick() {
+        this.lastProactiveTickAt = await runProactiveMaintenance({
+            config: this.config,
+            llmClient: this.llmClient,
+            state: this.state,
+            lastProactiveTickAt: this.lastProactiveTickAt,
+            logger: this.logger,
+        });
+    }
+    // ─── Private: Adaptive Sleep ───
+    /**
+     * Get the highest gap score across all active goals.
+     * Falls back to 0 if no gap data is available.
+     */
+    async getMaxGapScore(goalIds, snapshot) {
+        return getMaxGapScoreForGoals(this.driveSystem, goalIds, snapshot);
+    }
+    /**
+     * Thin wrapper delegating to the standalone calculateAdaptiveInterval function.
+     * Passes this.config.adaptive_sleep as the config parameter.
+     * Kept as a class method so tests can call daemon.calculateAdaptiveInterval(...).
+     */
+    calculateAdaptiveInterval(baseInterval, goalsActivatedThisCycle, maxGapScore, consecutiveIdleCycles) {
+        return calcAdaptiveInterval(baseInterval, goalsActivatedThisCycle, maxGapScore, consecutiveIdleCycles, this.config.adaptive_sleep);
+    }
+    // ─── Private: Shutdown Marker ───
+    /**
+     * Write shutdown-state.json to baseDir (async, atomic).
+     */
+    async writeShutdownMarker(marker) {
+        await writeShutdownMarkerFile(this.baseDir, marker, this.logger);
+    }
+    /**
+     * Read shutdown-state.json from baseDir.
+     * Returns null if file doesn't exist or fails to parse.
+     */
+    async readShutdownMarker() {
+        return readShutdownMarkerFile(this.baseDir);
+    }
+    /**
+     * Delete shutdown-state.json (after successful resume).
+     */
+    async deleteShutdownMarker() {
+        await deleteShutdownMarkerFile(this.baseDir);
+    }
+    /**
+     * Check for a previous shutdown marker and log recovery information.
+     * Called at startup before the main loop begins.
+     */
+    async checkCrashRecovery() {
+        await checkCrashRecoveryMarker(this.baseDir, this.logger);
+    }
+    // ─── Log Rotation (delegates to daemon-health) ───
+    /**
+     * Rotate the main log file if it exceeds the configured size limit.
+     * Delegates to rotateDaemonLog() with explicit config params.
+     * Called at daemon startup.
+     */
+    async rotateLog() {
+        const maxSizeBytes = this.config.log_rotation.max_size_mb * 1024 * 1024;
+        const maxFiles = this.config.log_rotation.max_files;
+        await rotateDaemonLog(this.logPath, this.logDir, maxSizeBytes, maxFiles, this.logger);
+    }
+    // ─── Static Utilities (delegates to daemon-signals) ───
+    /**
+     * Generate a crontab entry that runs `pulseed run --goal <goalId>` on a schedule.
+     * Delegates to the standalone generateCronEntry() function in daemon-signals.ts.
+     */
+    static generateCronEntry(goalId, intervalMinutes = 60) {
+        return generateCronEntry(goalId, intervalMinutes);
+    }
+}
+//# sourceMappingURL=runner.js.map