pulseed 0.3.0 → 0.4.1

package/dist/runtime/daemon-runner.js

@@ -1,875 +1,2 @@
-import * as fsp from "node:fs/promises";
-import * as path from "node:path";
-import { writeJsonFileAtomic, readJsonFileOrNull } from "../base/utils/json-io.js";
-import { EventServer } from "./event-server.js";
-import { DaemonConfigSchema, DaemonStateSchema } from "../base/types/daemon.js";
-import { getInternalIdentityPrefix } from "../base/config/identity-loader.js";
-import { z } from "zod";
-import { generateCronEntry } from "./daemon-signals.js";
-import { rotateDaemonLog, calculateAdaptiveInterval as calcAdaptiveInterval } from "./daemon-health.js";
-import { HttpChannelAdapter } from "./gateway/index.js";
-import { createEnvelope } from "./types/envelope.js";
-import { LoopSupervisor } from "./executor/index.js";
-import { PulSeedEventSchema } from "../base/types/drive.js";
-// Re-exports for callers that imported these from daemon-runner
-export { generateCronEntry } from "./daemon-signals.js";
-export { rotateDaemonLog, calculateAdaptiveInterval } from "./daemon-health.js";
-export class DaemonRunner {
-    coreLoop;
-    driveSystem;
-    stateManager;
-    pidManager;
-    logger;
-    config;
-    running = false;
-    shuttingDown = false;
-    state;
-    baseDir;
-    logDir;
-    logPath;
-    shutdownHandler = null;
-    eventServer;
-    approvalFn;
-    sleepAbortController = null;
-    currentGoalIds = [];
-    currentLoopIndex = 0;
-    lastProactiveTickAt = 0;
-    llmClient;
-    cronScheduler;
-    scheduleEngine;
-    consecutiveIdleCycles = 0;
-    gateway;
-    eventBus;
-    commandBus;
-    supervisor = null;
-    cronScheduleInterval = null;
-    shutdownResolve = null;
-    deps;
-    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.cronScheduler = deps.cronScheduler;
-        this.scheduleEngine = deps.scheduleEngine;
-        this.gateway = deps.gateway;
-        this.eventBus = deps.eventBus;
-        this.commandBus = deps.commandBus;
-        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");
-        // 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,
-        });
-    }
-    // ─── Public API ───
-    /**
-     * Start daemon loop for given goals.
-     * Throws if daemon is already running.
-     */
-    async start(goalIds) {
-        // 1. Check if already running
-        if (await this.pidManager.isRunning()) {
-            const info = await this.pidManager.readPID();
-            throw new Error(`Daemon is already running (PID ${info?.pid ?? "unknown"}). ` +
-                `Stop it first or remove the PID file at: ${this.pidManager.getPath()}`);
-        }
-        // 2. Write PID file
-        await this.pidManager.writePID();
-        // 2b. Rotate log if needed, then check for crash recovery marker
-        await this.rotateLog();
-        await this.checkCrashRecovery();
-        // 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,
-            }, this.logger);
-        }
-        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) => {
-                // Route by envelope type when buses are configured
-                if (envelope.type === "command" && this.commandBus) {
-                    this.commandBus.push(envelope);
-                    return;
-                }
-                if (envelope.type === "event" && this.eventBus) {
-                    this.eventBus.push(envelope);
-                    return;
-                }
-                // Fallback: no bus configured — keep legacy driveSystem.writeEvent() behavior
-                const payload = envelope.payload;
-                try {
-                    const event = PulSeedEventSchema.parse(payload);
-                    await this.driveSystem.writeEvent(event);
-                }
-                catch (err) {
-                    this.logger.error("Gateway: failed to process envelope", {
-                        id: envelope.id,
-                        error: String(err),
-                    });
-                }
-            });
-            // 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 {
-            // Legacy path: direct EventServer (no Gateway)
-            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) => {
-                return es.requestApproval(String(task["goal_id"] ?? "unknown"), {
-                    id: String(task["id"] ?? ""),
-                    description: String(task["description"] ?? ""),
-                    action: String(task["action"] ?? ""),
-                });
-            };
-        }
-        // Start heartbeat (every 30s)
-        const heartbeatInterval = setInterval(() => {
-            if (this.eventServer && this.state.status === "running") {
-                this.eventServer.broadcast("daemon_status", {
-                    status: this.state.status,
-                    activeGoals: this.state.active_goals,
-                    loopCount: this.state.loop_count,
-                    uptime: Date.now() - new Date(this.state.started_at).getTime(),
-                });
-            }
-        }, 30_000);
-        this.driveSystem.startWatcher((event) => this.onEventReceived(event));
-        // 3. Set up signal handlers for graceful shutdown
-        this.shuttingDown = false;
-        const shutdownTimeout = this.config.crash_recovery.graceful_shutdown_timeout_ms ?? 30_000;
-        let forceStopTimer = null;
-        const shutdown = () => {
-            if (this.shuttingDown)
-                return;
-            this.shuttingDown = true;
-            this.logger.info("Shutting down gracefully...");
-            // Abort current sleep so the loop exits promptly
-            this.sleepAbortController?.abort();
-            // Start a timeout to force-stop if graceful shutdown takes too long
-            forceStopTimer = setTimeout(() => {
-                this.logger.warn(`Graceful shutdown timeout (${shutdownTimeout}ms) exceeded, forcing stop`);
-                this.running = false;
-            }, shutdownTimeout);
-        };
-        this.shutdownHandler = shutdown;
-        process.on("SIGTERM", shutdown);
-        process.on("SIGINT", shutdown);
-        // 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,
-        });
-        // 7. Create supervisor if not already provided and eventBus is configured
-        if (!this.supervisor && this.eventBus) {
-            const factory = this.deps.coreLoopFactory ?? (() => this.coreLoop);
-            this.supervisor = new LoopSupervisor({
-                coreLoopFactory: factory,
-                eventBus: this.eventBus,
-                driveSystem: this.driveSystem,
-                stateManager: this.stateManager,
-                logger: this.logger,
-                onEscalation: (goalId, crashCount, lastError) => {
-                    this.logger.error(`Goal ${goalId} suspended after ${crashCount} crashes: ${lastError}`);
-                },
-            }, { iterationsPerCycle: this.config.iterations_per_cycle });
-        }
-        // 8. Run main loop — supervisor mode when supervisor is injected via deps,
-        //    fallback to sequential runLoop otherwise (preserves backward compat for
-        //    tests that provide eventBus without a supervisor)
-        try {
-            if (this.supervisor && this.eventBus) {
-                // Supervisor handles goal execution; cron/schedule must also run in this mode.
-                await this.supervisor.start(mergedGoalIds);
-                // Run cron/schedule processing once immediately, then on a periodic interval.
-                const cronIntervalMs = this.config.check_interval_ms;
-                await this.processCronTasks();
-                await this.processScheduleEntries();
-                this.cronScheduleInterval = setInterval(async () => {
-                    if (this.shuttingDown)
-                        return;
-                    await this.processCronTasks();
-                    await this.processScheduleEntries();
-                }, cronIntervalMs);
-                // 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(mergedGoalIds);
-            }
-        }
-        finally {
-            // Cancel the force-stop timer if it's still pending
-            if (forceStopTimer !== null) {
-                clearTimeout(forceStopTimer);
-                forceStopTimer = null;
-            }
-            // Remove signal handlers
-            if (this.shutdownHandler) {
-                process.removeListener("SIGTERM", this.shutdownHandler);
-                process.removeListener("SIGINT", this.shutdownHandler);
-                this.shutdownHandler = null;
-            }
-            // Stop file watcher and EventServer
-            clearInterval(heartbeatInterval);
-            if (this.cronScheduleInterval !== null) {
-                clearInterval(this.cronScheduleInterval);
-                this.cronScheduleInterval = null;
-            }
-            await this.supervisor?.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");
-            }
-        }
-    }
-    /** Expose approvalFn for callers (e.g. cmdStart) to wire into TaskLifecycle */
-    getApprovalFn() {
-        return this.approvalFn;
-    }
-    /**
-     * Abort the current sleep cycle immediately.
-     * Intended for use as the onHighPriority callback when constructing EventBus/CommandBus:
-     *   new EventBus({ onHighPriority: () => daemon.abortSleep() })
-     */
-    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(goalIds) {
-        while (this.running && !this.shuttingDown) {
-            try {
-                // 1. Determine which goals need activation
-                const activeGoals = await this.determineActiveGoals(goalIds);
-                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);
-                            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) {
-                    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);
-                    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) {
-        const eligibleIds = [];
-        const scores = new Map();
-        for (const goalId of goalIds) {
-            if (await this.driveSystem.shouldActivate(goalId)) {
-                eligibleIds.push(goalId);
-                // Load goal to get a rough priority signal (gap or drive score not available here)
-                // Use schedule consecutive_actions as a tiebreaker — more urgent goals first
-                const schedule = await this.driveSystem.getSchedule(goalId);
-                // Higher consecutive_actions = more urgent (stalled goal). Use inverse of next_check_at
-                // as a proxy: goals that are most overdue rank highest.
-                const nextCheckAt = schedule
-                    ? new Date(schedule.next_check_at).getTime()
-                    : 0;
-                // Earlier next_check_at means more overdue → assign higher (inverted) score
-                scores.set(goalId, -nextCheckAt);
-            }
-        }
-        // Sort by priority: most overdue first
-        return this.driveSystem.prioritizeGoals(eligibleIds, scores);
-    }
-    // ─── 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) {
-        const goalIntervals = this.config.goal_intervals;
-        if (!goalIntervals || goalIds.length === 0) {
-            return this.config.check_interval_ms;
-        }
-        let minInterval = this.config.check_interval_ms;
-        for (const goalId of goalIds) {
-            const override = goalIntervals[goalId];
-            if (override !== undefined && override < minInterval) {
-                minInterval = override;
-            }
-        }
-        return minInterval;
-    }
-    // ─── 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() {
-        const statePath = path.join(this.baseDir, "daemon-state.json");
-        try {
-            await writeJsonFileAtomic(statePath, this.state);
-        }
-        catch (err) {
-            // Non-fatal — log but don't crash the daemon
-            this.logger.warn("Failed to save daemon state", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    /**
-     * Load daemon state from {baseDir}/daemon-state.json.
-     * Returns null if the file doesn't exist or fails to parse.
-     */
-    async loadDaemonState() {
-        const statePath = path.join(this.baseDir, "daemon-state.json");
-        const data = await readJsonFileOrNull(statePath);
-        if (data === null)
-            return null;
-        try {
-            return DaemonStateSchema.parse(data);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 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) {
-        const saved = await this.loadDaemonState();
-        if (!saved || !saved.interrupted_goals || saved.interrupted_goals.length === 0) {
-            return goalIds;
-        }
-        const merged = Array.from(new Set([...goalIds, ...saved.interrupted_goals]));
-        if (merged.length > goalIds.length) {
-            this.logger.info("Restored interrupted goals from previous run", {
-                interrupted: saved.interrupted_goals,
-                merged,
-            });
-        }
-        return merged;
-    }
-    // ─── Private: Cleanup ───
-    /**
-     * Perform cleanup after the loop exits: update state, remove PID file, log.
-     * Also writes "clean_shutdown" marker to enable crash-vs-clean detection on next startup.
-     */
-    async cleanup() {
-        // Only set to "stopped" if not already "crashed"
-        const wasCrashed = this.state.status === "crashed";
-        if (!wasCrashed) {
-            this.state.status = "stopped";
-        }
-        await this.saveDaemonState();
-        await this.pidManager.cleanup();
-        // Write clean shutdown marker (async, atomic)
-        const markerPath = path.join(this.baseDir, "shutdown-state.json");
-        const marker = {
-            goal_ids: this.currentGoalIds,
-            loop_index: this.currentLoopIndex,
-            timestamp: new Date().toISOString(),
-            reason: wasCrashed ? "max_retries" : "stop",
-            state: wasCrashed ? "running" : "clean_shutdown",
-        };
-        try {
-            await writeJsonFileAtomic(markerPath, marker);
-        }
-        catch (err) {
-            this.logger.warn("Failed to write shutdown marker", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-        this.logger.info("Daemon stopped", {
-            loop_count: this.state.loop_count,
-            crash_count: this.state.crash_count,
-        });
-    }
-    // ─── Private: Cron Scheduler ───
-    /**
-     * Process due cron-scheduled tasks.
-     * Logs each task, executes based on type, and marks as fired.
-     */
-    async processCronTasks() {
-        if (!this.cronScheduler)
-            return;
-        try {
-            const dueTasks = await this.cronScheduler.getDueTasks();
-            for (const task of dueTasks) {
-                this.logger.info(`Cron task due: ${task.id} (type=${task.type})`, {
-                    cron: task.cron,
-                    type: task.type,
-                });
-                if (this.eventBus) {
-                    // Push to eventBus — markFired happens when the envelope is consumed, not at push time
-                    const envelope = createEnvelope({
-                        type: "event",
-                        name: "cron_task_due",
-                        source: "cron-scheduler",
-                        priority: "normal",
-                        payload: task,
-                        dedupe_key: `cron-${task.id}`,
-                    });
-                    this.eventBus.push(envelope);
-                    this.logger.info(`Cron task enqueued to eventBus: ${task.id}`);
-                }
-                else {
-                    // Fallback: no eventBus — execute and markFired directly (legacy behavior)
-                    try {
-                        // Log the task prompt and type for observability; actual execution
-                        // varies by type but all are currently handled as fire-and-log.
-                        this.logger.info(`Executing cron task: ${task.type}`, {
-                            prompt: task.prompt,
-                        });
-                        await this.cronScheduler.markFired(task.id);
-                        this.logger.info(`Cron task fired: ${task.id}`);
-                    }
-                    catch (err) {
-                        this.logger.warn(`Cron task ${task.id} failed`, {
-                            error: err instanceof Error ? err.message : String(err),
-                        });
-                        // Still mark as fired to avoid retry-storms
-                        await this.cronScheduler.markFired(task.id);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            // Non-fatal — cron errors should not crash the daemon
-            this.logger.warn("Failed to process cron tasks", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    /**
-     * Process due schedule engine entries.
-     */
-    async processScheduleEntries() {
-        if (!this.scheduleEngine)
-            return;
-        try {
-            const results = await this.scheduleEngine.tick();
-            for (const result of results) {
-                if (result.status === "error") {
-                    this.logger?.warn?.(`Schedule entry ${result.entry_id} failed: ${result.error_message}`);
-                }
-                else if (this.eventBus) {
-                    // Push activated schedule entries to eventBus as envelopes
-                    const goalId = result["goal_id"];
-                    if (!goalId) {
-                        this.logger.warn("schedule_activated envelope missing goal_id", { entry_id: result["entry_id"] });
-                    }
-                    const envelope = createEnvelope({
-                        type: "event",
-                        name: "schedule_activated",
-                        source: "schedule-engine",
-                        goal_id: goalId,
-                        priority: "normal",
-                        payload: result,
-                        dedupe_key: result.entry_id,
-                    });
-                    this.eventBus.push(envelope);
-                }
-            }
-        }
-        catch (error) {
-            this.logger?.error?.("Failed to process schedule entries", { error: error instanceof Error ? error.message : String(error) });
-        }
-    }
-    /**
-     * Expire old non-permanent cron tasks.
-     */
-    async expireCronTasks() {
-        if (!this.cronScheduler)
-            return;
-        try {
-            await this.cronScheduler.expireOldTasks();
-            this.logger.debug("Expired old cron tasks");
-        }
-        catch (err) {
-            this.logger.warn("Failed to expire cron tasks", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    // ─── 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();
-    }
-    // ─── Private: Proactive Tick ───
-    // Zod schema for the LLM proactive action response
-    static ProactiveResponseSchema = z.object({
-        action: z.enum(["suggest_goal", "investigate", "preemptive_check", "sleep"]),
-        details: z.record(z.string(), z.unknown()).optional(),
-    });
-    /**
-     * 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() {
-        if (!this.config.proactive_mode)
-            return;
-        if (!this.llmClient)
-            return;
-        if (Date.now() - this.lastProactiveTickAt < this.config.proactive_interval_ms)
-            return;
-        try {
-            // Build a brief summary of all tracked goals from daemon state
-            const goalSummaries = this.state.active_goals.length > 0
-                ? this.state.active_goals.map((id) => `- ${id}`).join("\n")
-                : "(no active goals)";
-            const prompt = `${getInternalIdentityPrefix("proactive engine")} Given the current state of all goals:\n${goalSummaries}\n\nDecide what action to take:\n- "suggest_goal": A new goal should be created (provide title + description)\n- "investigate": Something needs investigation (provide what and why)\n- "preemptive_check": Run a pre-emptive observation (provide goal_id)\n- "sleep": Nothing needs attention right now\n\nRespond with JSON: { "action": "...", "details": { ... } }`;
-            const response = await this.llmClient.sendMessage([{ role: "user", content: prompt }], { model_tier: "light" });
-            const parsed = DaemonRunner.ProactiveResponseSchema.safeParse(this.llmClient.parseJSON(response.content, DaemonRunner.ProactiveResponseSchema));
-            if (!parsed.success) {
-                this.logger.warn("Proactive tick: failed to parse LLM response", {
-                    raw: response.content,
-                    error: parsed.error.message,
-                });
-                this.lastProactiveTickAt = Date.now();
-                return;
-            }
-            const { action, details } = parsed.data;
-            if (action === "sleep") {
-                this.logger.debug("Proactive tick: LLM decided to sleep");
-            }
-            else {
-                this.logger.info(`Proactive tick: action=${action}`, { details });
-            }
-        }
-        catch (err) {
-            this.logger.warn("Proactive tick: LLM error (ignored)", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-        this.lastProactiveTickAt = Date.now();
-    }
-    // ─── 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) {
-        let max = 0;
-        for (const goalId of goalIds) {
-            try {
-                const schedule = await this.driveSystem.getSchedule(goalId);
-                if (schedule && typeof schedule["last_gap_score"] === "number") {
-                    const score = schedule["last_gap_score"];
-                    if (score > max)
-                        max = score;
-                }
-            }
-            catch {
-                // Non-fatal — just use 0 for this goal
-            }
-        }
-        return max;
-    }
-    /**
-     * 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) {
-        const markerPath = path.join(this.baseDir, "shutdown-state.json");
-        try {
-            await writeJsonFileAtomic(markerPath, marker);
-        }
-        catch (err) {
-            this.logger.warn("Failed to write shutdown marker", {
-                error: err instanceof Error ? err.message : String(err),
-            });
-        }
-    }
-    /**
-     * Read shutdown-state.json from baseDir.
-     * Returns null if file doesn't exist or fails to parse.
-     */
-    async readShutdownMarker() {
-        const markerPath = path.join(this.baseDir, "shutdown-state.json");
-        return readJsonFileOrNull(markerPath);
-    }
-    /**
-     * Delete shutdown-state.json (after successful resume).
-     */
-    async deleteShutdownMarker() {
-        const markerPath = path.join(this.baseDir, "shutdown-state.json");
-        try {
-            await fsp.unlink(markerPath);
-        }
-        catch {
-            // File may not exist — ignore
-        }
-    }
-    /**
-     * Check for a previous shutdown marker and log recovery information.
-     * Called at startup before the main loop begins.
-     */
-    async checkCrashRecovery() {
-        const marker = await this.readShutdownMarker();
-        if (!marker)
-            return;
-        if (marker.state === "clean_shutdown") {
-            this.logger.info("Resuming from clean shutdown", {
-                previous_loop_index: marker.loop_index,
-                previous_goals: marker.goal_ids,
-                shutdown_at: marker.timestamp,
-            });
-        }
-        else {
-            // state === "running" — previous instance did not shut down cleanly
-            this.logger.warn("Recovering from crash — previous instance did not shut down cleanly", {
-                previous_loop_index: marker.loop_index,
-                previous_goals: marker.goal_ids,
-                last_seen_at: marker.timestamp,
-            });
-        }
-        // Delete the marker; we'll write a fresh "running" marker in start()
-        await this.deleteShutdownMarker();
-    }
-    // ─── 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);
-    }
-}
+export * from "./daemon/runner.js";
 //# sourceMappingURL=daemon-runner.js.map