pulseed 0.2.0 → 0.4.0

package/dist/runtime/daemon-runner.js

@@ -1,10 +1,22 @@
 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";
+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";
 // Re-exports for callers that imported these from daemon-runner
 export { generateCronEntry } from "./daemon-signals.js";
 export { rotateDaemonLog, calculateAdaptiveInterval } from "./daemon-health.js";
@@ -23,14 +35,34 @@ export class DaemonRunner {
     logPath;
     shutdownHandler = null;
     eventServer;
+    approvalFn;
     sleepAbortController = null;
     currentGoalIds = [];
     currentLoopIndex = 0;
     lastProactiveTickAt = 0;
     llmClient;
+    reportingEngine;
     cronScheduler;
+    scheduleEngine;
     consecutiveIdleCycles = 0;
+    gateway;
+    eventBus;
+    commandBus;
+    supervisor = null;
+    cronScheduleInterval = null;
+    shutdownResolve = null;
+    deps;
+    runtimeRoot = null;
+    approvalStore = null;
+    outboxStore = null;
+    runtimeHealthStore = null;
+    leaderLockManager = null;
+    goalLeaseManager = null;
+    journalQueue = null;
+    queueClaimSweeper = null;
+    approvalBroker = null;
     constructor(deps) {
+        this.deps = deps;
         this.coreLoop = deps.coreLoop;
         this.driveSystem = deps.driveSystem;
         this.stateManager = deps.stateManager;
@@ -38,7 +70,13 @@ export class DaemonRunner {
         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.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 ?? {});
@@ -47,6 +85,25 @@ export class DaemonRunner {
         // 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");
+        if (this.config.runtime_journal_v2) {
+            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,
+            });
+        }
         // Initialize daemon state
         this.state = DaemonStateSchema.parse({
             pid: process.pid,
@@ -59,6 +116,15 @@ export class DaemonRunner {
             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.
@@ -71,20 +137,85 @@ export class DaemonRunner {
             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
+        // 2. Rotate log if needed, then check for crash recovery marker
         await this.rotateLog();
         await this.checkCrashRecovery();
-        // 2c. Start EventServer (if provided) and file watcher
-        if (this.eventServer) {
+        await this.initializeRuntimeFoundation();
+        // 2b. Publish PID only after startup prerequisites succeed.
+        await this.pidManager.writePID();
+        // 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.approvalBroker) {
+            this.approvalBroker.setBroadcast((eventType, data) => {
+                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 {
+            // Legacy path: direct EventServer (no Gateway)
             await this.eventServer.start();
             this.eventServer.startFileWatcher();
-            this.logger.info("EventServer started", {
-                host: this.eventServer.getHost(),
-                port: this.eventServer.getPort(),
-            });
+            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,
+                });
+            };
         }
+        // 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;
@@ -137,9 +268,72 @@ export class DaemonRunner {
             goals: mergedGoalIds,
             check_interval_ms: this.config.check_interval_ms,
         });
-        // 7. Run main loop
+        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 and runtime execution wiring is configured
+        if (!this.supervisor && (this.eventBus || (this.journalQueue && this.goalLeaseManager))) {
+            const factory = this.deps.coreLoopFactory ?? (() => this.coreLoop);
+            this.supervisor = new LoopSupervisor({
+                coreLoopFactory: factory,
+                eventBus: this.eventBus,
+                journalQueue: this.journalQueue ?? undefined,
+                goalLeaseManager: this.goalLeaseManager ?? undefined,
+                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 });
+        }
+        await this.saveRuntimeHealthSnapshot(this.supervisor && this.journalQueue && this.goalLeaseManager
+            ? "execution_ownership_durable"
+            : "foundation_only", {
+            gateway: this.gateway || this.eventServer ? "ok" : "degraded",
+            queue: this.journalQueue ? "ok" : "degraded",
+            leases: this.goalLeaseManager ? "ok" : "degraded",
+            approval: this.approvalStore ? "ok" : "degraded",
+            outbox: this.outboxStore ? "ok" : "degraded",
+            supervisor: this.supervisor && this.journalQueue && this.goalLeaseManager ? "ok" : "degraded",
+        });
+        // 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)
+        let cleanupHandled = false;
         try {
-            await this.runLoop(mergedGoalIds);
+            if (this.supervisor) {
+                // 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);
+                cleanupHandled = true;
+            }
         }
         finally {
             // Cancel the force-stop timer if it's still pending
@@ -147,6 +341,7 @@ export class DaemonRunner {
                 clearTimeout(forceStopTimer);
                 forceStopTimer = null;
             }
+            this.queueClaimSweeper?.stop();
             // Remove signal handlers
             if (this.shutdownHandler) {
                 process.removeListener("SIGTERM", this.shutdownHandler);
@@ -154,20 +349,83 @@ export class DaemonRunner {
                 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.eventServer) {
+            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();
+            }
         }
     }
+    async initializeRuntimeFoundation() {
+        if (!this.config.runtime_journal_v2)
+            return;
+        await Promise.all([
+            this.approvalStore?.ensureReady(),
+            this.outboxStore?.ensureReady(),
+            this.runtimeHealthStore?.ensureReady(),
+        ]);
+        await this.saveRuntimeHealthSnapshot("foundation_only", {
+            gateway: "degraded",
+            queue: "degraded",
+            leases: "ok",
+            approval: "ok",
+            outbox: "ok",
+            supervisor: "degraded",
+        });
+        this.logger.info("Runtime journal foundation initialized", {
+            runtime_root: this.runtimeRoot,
+            queue_path: this.runtimeRoot ? path.join(this.runtimeRoot, "queue.json") : undefined,
+        });
+    }
+    async saveRuntimeHealthSnapshot(phase, components) {
+        if (!this.config.runtime_journal_v2)
+            return;
+        const status = Object.values(components).every((value) => value === "ok") ? "ok" : "degraded";
+        await this.runtimeHealthStore?.saveSnapshot({
+            status,
+            leader: false,
+            checked_at: Date.now(),
+            components,
+            details: {
+                runtime_journal_v2: true,
+                runtime_root: this.runtimeRoot,
+                phase,
+            },
+        });
+    }
+    /** 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
@@ -205,6 +463,14 @@ export class DaemonRunner {
                             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);
@@ -215,8 +481,18 @@ export class DaemonRunner {
                 }
                 // 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();
@@ -389,6 +665,9 @@ export class DaemonRunner {
         const wasCrashed = this.state.status === "crashed";
         if (!wasCrashed) {
             this.state.status = "stopped";
+            if (this.state.interrupted_goals === undefined) {
+                this.state.interrupted_goals = [...this.state.active_goals];
+            }
         }
         await this.saveDaemonState();
         await this.pidManager.cleanup();
@@ -429,21 +708,40 @@ export class DaemonRunner {
                     cron: task.cron,
                     type: task.type,
                 });
-                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}`);
+                const envelope = createEnvelope({
+                    type: "event",
+                    name: "cron_task_due",
+                    source: "cron-scheduler",
+                    priority: "normal",
+                    payload: task,
+                    dedupe_key: `cron-${task.id}`,
+                });
+                if (!this.acceptRuntimeEnvelope(envelope)) {
+                    continue;
                 }
-                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);
+                if (this.eventBus) {
+                    // Push to eventBus — markFired happens when the envelope is consumed, not at push time
+                    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);
+                    }
                 }
             }
         }
@@ -454,6 +752,46 @@ export class DaemonRunner {
             });
         }
     }
+    /**
+     * 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 {
+                    // Record schedule activation in the runtime journal before any in-memory fanout.
+                    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,
+                    });
+                    if (!this.acceptRuntimeEnvelope(envelope)) {
+                        continue;
+                    }
+                    if (this.eventBus) {
+                        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.
      */
@@ -499,6 +837,49 @@ export class DaemonRunner {
         });
         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;
+        }
+        if (envelope.type === "command") {
+            if (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),
+            });
+        }
+    }
     // ─── Private: Proactive Tick ───
     // Zod schema for the LLM proactive action response
     static ProactiveResponseSchema = z.object({
@@ -522,7 +903,7 @@ export class DaemonRunner {
             const goalSummaries = this.state.active_goals.length > 0
                 ? this.state.active_goals.map((id) => `- ${id}`).join("\n")
                 : "(no active goals)";
-            const prompt = `You are PulSeed's 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 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) {