pulseed 0.4.4 → 0.4.6

package/dist/runtime/daemon/runner.js

@@ -1,15 +1,15 @@
 import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import { spawnSync } from "node:child_process";
-import { TaskSchema } from "../../base/types/task.js";
 import { getProviderRuntimeFingerprint } from "../../base/llm/provider-config.js";
 import { EventServer } from "../event/server.js";
 import { DaemonConfigSchema, DaemonStateSchema, ResidentActivitySchema } from "../../base/types/daemon.js";
+import { lintAgentMemory } from "../../platform/knowledge/knowledge-manager-lint.js";
 import { DreamAnalyzer } from "../../platform/dream/dream-analyzer.js";
+import { DreamConsolidator } from "../../platform/dream/dream-consolidator.js";
 import { DreamScheduleSuggestionStore } from "../../platform/dream/dream-schedule-suggestions.js";
+import { createRuntimeDreamSoilSyncService } from "../../platform/dream/dream-soil-sync.js";
 import { runDreamConsolidation } from "../../reflection/dream-consolidation.js";
-import { PipelineStateSchema } from "../../base/types/pipeline.js";
 import { generateCronEntry } from "./signals.js";
 import { rotateDaemonLog, calculateAdaptiveInterval as calcAdaptiveInterval } from "./health.js";
 import { HttpChannelAdapter } from "../gateway/index.js";
@@ -25,10 +25,14 @@ 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 { handleCriticalDaemonError, handleDaemonLoopError, runCommandWithHealth as runCommandWithHealthFn, } from "./runner-errors.js";
+import { reconcileInterruptedExecutions as reconcileInterruptedExecutionsFn } from "./runner-recovery.js";
 import { checkCrashRecoveryMarker, cleanupDaemonRun, collectGoalCycleScheduleSnapshot, deleteShutdownMarkerFile, determineActiveGoalsForCycle, expireOldCronTasks, getMaxGapScoreForGoals, getNextIntervalForGoals, processCronTasksForDaemon, processScheduleEntriesForDaemon, runRuntimeStoreMaintenanceCycle, readShutdownMarkerFile, restoreInterruptedGoals, runProactiveMaintenance, runSupervisorMaintenanceCycleForDaemon, saveDaemonStateFile, writeChatMessageEvent, writeShutdownMarkerFile, } from "./index.js";
-import { appendTaskOutcomeEvent } from "../../orchestrator/execution/task/task-outcome-ledger.js";
-import { durationToMs } from "../../orchestrator/execution/task/task-executor.js";
 const RUNTIME_JOURNAL_MAX_ATTEMPTS = 1_000;
+function resolveResidentWorkspaceDir(configuredPath) {
+    const trimmed = configuredPath?.trim();
+    return trimmed ? path.resolve(trimmed) : process.cwd();
+}
 function gatherResidentWorkspaceContext(workspaceDir, seedDescription) {
     const parts = [`Workspace: ${workspaceDir}`];
     const seed = seedDescription?.trim();
@@ -132,6 +136,8 @@ export class DaemonRunner {
     shutdownCoordinator = null;
     stopStatusHeartbeat = null;
     lastRuntimeStoreMaintenanceAt = 0;
+    startupRuntimeStoreMaintenancePromise = null;
+    startupRuntimeStoreMaintenanceError = null;
     deps;
     runtimeRoot = null;
     approvalStore = null;
@@ -248,7 +254,6 @@ export class DaemonRunner {
             await this.checkCrashRecovery();
             await this.initializeRuntimeFoundation();
             await this.acquireRuntimeLeadership();
-            await this.runRuntimeStoreMaintenance(true);
             // 2c. Start EventServer (always-on) and file watcher
             if (!this.eventServer) {
                 const esPort = this.config.event_server_port ?? 41700;
@@ -439,6 +444,7 @@ export class DaemonRunner {
                 outbox: "ok",
                 supervisor: this.supervisor ? "ok" : "degraded",
             });
+            this.startStartupRuntimeStoreMaintenance();
             // 8. Run main loop — supervisor mode when supervisor is injected via deps,
             //    fallback to sequential runLoop otherwise.
             startupReady = true;
@@ -500,7 +506,12 @@ export class DaemonRunner {
         }
         catch (err) {
             if (!startupReady) {
-                await this.releaseStartupOwnership();
+                try {
+                    await this.drainStartupRuntimeStoreMaintenance();
+                }
+                finally {
+                    await this.releaseStartupOwnership();
+                }
             }
             throw err;
         }
@@ -687,17 +698,15 @@ export class DaemonRunner {
      * 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++;
-        void this.runtimeOwnership.observeTaskExecution("failed", `loop error for ${goalId}: ${this.state.last_error}`);
-        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,
+        const { shouldStop } = handleDaemonLoopError({
+            goalId,
+            error: err,
+            state: this.state,
+            maxRetries: this.config.crash_recovery.max_retries,
+            logger: this.logger,
+            observeTaskExecution: (status, reason) => this.runtimeOwnership.observeTaskExecution(status, reason),
         });
-        // 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`);
+        if (shouldStop) {
             this.running = false;
         }
     }
@@ -706,13 +715,13 @@ export class DaemonRunner {
      * 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 });
-        await this.runtimeOwnership.observeTaskExecution("failed", `critical daemon error: ${msg}`);
-        this.state.status = "crashed";
-        this.state.last_error = msg;
-        this.state.interrupted_goals = [...this.state.active_goals];
-        await this.saveDaemonState();
+        await handleCriticalDaemonError({
+            error: err,
+            state: this.state,
+            logger: this.logger,
+            observeTaskExecution: (status, reason) => this.runtimeOwnership.observeTaskExecution(status, reason),
+            saveDaemonState: () => this.saveDaemonState(),
+        });
         this.running = false;
     }
     // ─── Private: State Persistence ───
@@ -731,143 +740,11 @@ export class DaemonRunner {
         return restoreInterruptedGoals(this.baseDir, goalIds, this.logger);
     }
     async reconcileInterruptedExecutions() {
-        const recoveredGoalIds = new Set();
-        const now = new Date().toISOString();
-        for (const task of await this.findRunningTasks()) {
-            const recoveredTask = TaskSchema.parse({
-                ...task,
-                status: "error",
-                completed_at: task.completed_at ?? now,
-                heartbeat_at: now,
-                execution_output: [
-                    task.execution_output,
-                    "[RECOVERED] Task execution was interrupted by daemon crash or restart before completion.",
-                ]
-                    .filter((value) => typeof value === "string" && value.length > 0)
-                    .join("\n"),
-            });
-            await this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, recoveredTask);
-            await this.appendRecoveredTaskHistory(recoveredTask);
-            await appendTaskOutcomeEvent(this.stateManager, {
-                task: recoveredTask,
-                type: "failed",
-                attempt: Math.max(task.consecutive_failure_count + 1, 1),
-                reason: "task execution interrupted by daemon recovery",
-            });
-            await appendTaskOutcomeEvent(this.stateManager, {
-                task: recoveredTask,
-                type: "retried",
-                attempt: Math.max(task.consecutive_failure_count + 1, 1),
-                action: "keep",
-                reason: "daemon restarted; task preserved for retry",
-            });
-            recoveredGoalIds.add(task.goal_id);
-        }
-        await this.reconcileInterruptedPipelines(now);
-        if (recoveredGoalIds.size > 0) {
-            this.logger.warn("Recovered interrupted task executions on startup", {
-                goals: [...recoveredGoalIds],
-                count: recoveredGoalIds.size,
-            });
-        }
-        return [...recoveredGoalIds];
-    }
-    async findRunningTasks() {
-        const tasksDir = path.join(this.baseDir, "tasks");
-        let goalDirs;
-        try {
-            goalDirs = await fsp.readdir(tasksDir, { withFileTypes: true });
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                return [];
-            }
-            throw err;
-        }
-        const runningTasks = [];
-        for (const goalDir of goalDirs) {
-            if (!goalDir.isDirectory()) {
-                continue;
-            }
-            const goalTaskDir = path.join(tasksDir, goalDir.name);
-            let taskEntries;
-            try {
-                taskEntries = await fsp.readdir(goalTaskDir, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of taskEntries) {
-                if (!entry.isFile() || !entry.name.endsWith(".json") || entry.name === "task-history.json") {
-                    continue;
-                }
-                try {
-                    const raw = await this.stateManager.readRaw(`tasks/${goalDir.name}/${entry.name}`);
-                    if (!raw || typeof raw !== "object" || raw.status !== "running") {
-                        continue;
-                    }
-                    runningTasks.push(TaskSchema.parse(raw));
-                }
-                catch {
-                    // Ignore malformed task files during startup reconciliation.
-                }
-            }
-        }
-        return runningTasks;
-    }
-    async appendRecoveredTaskHistory(task) {
-        const historyPath = `tasks/${task.goal_id}/task-history.json`;
-        const existing = await this.stateManager.readRaw(historyPath);
-        const history = Array.isArray(existing) ? existing : [];
-        const actualElapsedMs = task.started_at && task.completed_at
-            ? new Date(task.completed_at).getTime() - new Date(task.started_at).getTime()
-            : null;
-        history.push({
-            task_id: task.id,
-            status: task.status,
-            primary_dimension: task.primary_dimension,
-            consecutive_failure_count: task.consecutive_failure_count,
-            completed_at: task.completed_at ?? new Date().toISOString(),
-            actual_elapsed_ms: actualElapsedMs,
-            estimated_duration_ms: task.estimated_duration ? durationToMs(task.estimated_duration) : null,
+        return reconcileInterruptedExecutionsFn({
+            baseDir: this.baseDir,
+            stateManager: this.stateManager,
+            logger: this.logger,
         });
-        await this.stateManager.writeRaw(historyPath, history);
-    }
-    async reconcileInterruptedPipelines(now) {
-        const pipelinesDir = path.join(this.baseDir, "pipelines");
-        let entries;
-        try {
-            entries = await fsp.readdir(pipelinesDir);
-        }
-        catch (err) {
-            if (err.code === "ENOENT") {
-                return;
-            }
-            throw err;
-        }
-        for (const entry of entries) {
-            if (!entry.endsWith(".json")) {
-                continue;
-            }
-            try {
-                const raw = await this.stateManager.readRaw(`pipelines/${entry}`);
-                if (!raw || typeof raw !== "object") {
-                    continue;
-                }
-                const pipelineState = PipelineStateSchema.parse(raw);
-                if (pipelineState.status !== "running") {
-                    continue;
-                }
-                await this.stateManager.writeRaw(`pipelines/${entry}`, {
-                    ...pipelineState,
-                    status: "interrupted",
-                    updated_at: now,
-                });
-            }
-            catch {
-                // Ignore malformed pipeline state during startup reconciliation.
-            }
-        }
     }
     // ─── Private: Cleanup ───
     /**
@@ -875,6 +752,13 @@ export class DaemonRunner {
      * Also writes "clean_shutdown" marker to enable crash-vs-clean detection on next startup.
      */
     async cleanup() {
+        let startupMaintenanceError = null;
+        try {
+            await this.drainStartupRuntimeStoreMaintenance();
+        }
+        catch (err) {
+            startupMaintenanceError = err;
+        }
         await cleanupDaemonRun({
             baseDir: this.baseDir,
             state: this.state,
@@ -883,6 +767,9 @@ export class DaemonRunner {
             runtimeOwnership: this.runtimeOwnership,
             logger: this.logger,
         });
+        if (startupMaintenanceError) {
+            throw startupMaintenanceError;
+        }
     }
     beginGracefulShutdown() {
         if (this.shuttingDown) {
@@ -1099,7 +986,7 @@ export class DaemonRunner {
         const hintedDescription = typeof details?.["description"] === "string" ? details["description"].trim() : "";
         const hintedTitle = typeof details?.["title"] === "string" ? details["title"].trim() : "";
         try {
-            const workspaceDir = process.cwd();
+            const workspaceDir = resolveResidentWorkspaceDir(this.config.workspace_path);
             const workspaceContext = gatherResidentWorkspaceContext(workspaceDir, hintedDescription);
             const existingTitles = await this.loadExistingGoalTitles();
             const suggestions = await this.goalNegotiator.suggestGoals(workspaceContext, {
@@ -1248,6 +1135,72 @@ export class DaemonRunner {
         });
         return analyzer.run({ tier });
     }
+    async runPlatformDreamConsolidation(tier) {
+        try {
+            const knowledgeManager = this.knowledgeManager;
+            const llmClient = this.llmClient;
+            const consolidator = new DreamConsolidator({
+                baseDir: this.baseDir,
+                logger: this.logger,
+                syncService: createRuntimeDreamSoilSyncService(),
+                memoryQualityService: knowledgeManager && llmClient
+                    ? {
+                        run: async (input) => {
+                            const result = await lintAgentMemory({
+                                km: knowledgeManager,
+                                llmCall: async (prompt) => {
+                                    const response = await llmClient.sendMessage([{ role: "user", content: prompt }], { max_tokens: 2000, model_tier: "light" });
+                                    return response.content;
+                                },
+                                autoRepair: input.autoRepair,
+                                minAutoRepairConfidence: input.minAutoRepairConfidence,
+                            });
+                            return {
+                                findings: result.findings.length,
+                                contradictionsFound: result.findings.filter((finding) => finding.type === "contradiction").length,
+                                stalenessFound: result.findings.filter((finding) => finding.type === "staleness").length,
+                                redundancyFound: result.findings.filter((finding) => finding.type === "redundancy").length,
+                                repairsApplied: result.repairs_applied,
+                                entriesFlagged: result.entries_flagged,
+                            };
+                        },
+                    }
+                    : undefined,
+                legacyConsolidationService: tier === "deep"
+                    ? {
+                        run: () => runDreamConsolidation({
+                            stateManager: this.stateManager,
+                            memoryLifecycle: this.memoryLifecycle,
+                            knowledgeManager: this.knowledgeManager,
+                            baseDir: this.baseDir,
+                        }),
+                    }
+                    : undefined,
+            });
+            return await consolidator.run({ tier });
+        }
+        catch (error) {
+            this.logger.warn("Platform Dream consolidation failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    legacyReportFromPlatformDream(report) {
+        const category = report?.categories.find((result) => result.category === "legacyReflectionCompatibility");
+        if (!category || category.status !== "completed") {
+            return null;
+        }
+        const legacy = report?.operational?.legacy_reflection;
+        return legacy
+            ? {
+                goals_consolidated: legacy.goals_consolidated,
+                entries_compressed: legacy.entries_compressed,
+                stale_entries_found: legacy.stale_entries_found,
+                revalidation_tasks_created: legacy.revalidation_tasks_created,
+            }
+            : null;
+    }
     async triggerResidentDreamMaintenance(details, tier = "deep") {
         try {
             const appliedBeforeAnalysis = await this.tryApplyPendingDreamSuggestion();
@@ -1264,8 +1217,9 @@ export class DaemonRunner {
             }
             const analysisReport = await this.runDreamAnalysis(tier);
             const appliedAfterAnalysis = tier === "deep" ? await this.tryApplyPendingDreamSuggestion() : null;
+            const platformReport = await this.runPlatformDreamConsolidation(tier);
             const consolidationReport = tier === "deep"
-                ? await runDreamConsolidation({
+                ? this.legacyReportFromPlatformDream(platformReport) ?? await runDreamConsolidation({
                     stateManager: this.stateManager,
                     memoryLifecycle: this.memoryLifecycle,
                     knowledgeManager: this.knowledgeManager,
@@ -1421,16 +1375,7 @@ export class DaemonRunner {
         this.abortSleep();
     }
     async runCommandWithHealth(commandName, fn) {
-        try {
-            const result = await fn();
-            await this.runtimeOwnership.observeCommandAcceptance("ok");
-            return result;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            await this.runtimeOwnership.observeCommandAcceptance("failed", `${commandName} failed: ${message}`);
-            throw error;
-        }
+        return runCommandWithHealthFn(commandName, fn, (status, reason) => this.runtimeOwnership.observeCommandAcceptance(status, reason));
     }
     async handleApprovalResponseCommand(goalId, requestId, approved) {
         if (this.approvalBroker) {
@@ -1474,6 +1419,32 @@ export class DaemonRunner {
             now,
         });
     }
+    startStartupRuntimeStoreMaintenance() {
+        if (this.startupRuntimeStoreMaintenancePromise) {
+            return;
+        }
+        this.startupRuntimeStoreMaintenanceError = null;
+        this.startupRuntimeStoreMaintenancePromise = this.runRuntimeStoreMaintenance(true)
+            .catch((err) => {
+            this.startupRuntimeStoreMaintenanceError = err;
+            this.logger.error("Startup runtime store maintenance failed", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        });
+    }
+    async drainStartupRuntimeStoreMaintenance() {
+        const maintenancePromise = this.startupRuntimeStoreMaintenancePromise;
+        if (!maintenancePromise) {
+            return;
+        }
+        await maintenancePromise;
+        this.startupRuntimeStoreMaintenancePromise = null;
+        const maintenanceError = this.startupRuntimeStoreMaintenanceError;
+        this.startupRuntimeStoreMaintenanceError = null;
+        if (maintenanceError) {
+            throw maintenanceError;
+        }
+    }
     // ─── Private: Proactive Tick ───
     /**
      * Ask the LLM for a proactive action when no goals were activated this cycle.