pulseed 0.4.3 → 0.4.6

package/dist/runtime/daemon/runner.js

@@ -1,6 +1,15 @@
+import * as fs from "node:fs";
 import * as path from "node:path";
+import { spawnSync } from "node:child_process";
+import { getProviderRuntimeFingerprint } from "../../base/llm/provider-config.js";
 import { EventServer } from "../event/server.js";
-import { DaemonConfigSchema, DaemonStateSchema } from "../../base/types/daemon.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 { generateCronEntry } from "./signals.js";
 import { rotateDaemonLog, calculateAdaptiveInterval as calcAdaptiveInterval } from "./health.js";
 import { HttpChannelAdapter } from "../gateway/index.js";
@@ -16,14 +25,85 @@ 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";
+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";
+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();
+    if (seed) {
+        parts.push(`Resident trigger hint: ${seed}`);
+    }
+    try {
+        const pkgPath = path.join(workspaceDir, "package.json");
+        const pkgRaw = fs.readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(pkgRaw);
+        const name = typeof pkg.name === "string" ? pkg.name : "";
+        const description = typeof pkg.description === "string" ? pkg.description : "";
+        const scripts = pkg.scripts && typeof pkg.scripts === "object"
+            ? Object.keys(pkg.scripts).join(", ")
+            : "";
+        const prefix = name ? `Node.js project '${name}'` : "Node.js project";
+        const descPart = description ? `. ${description}` : "";
+        const scriptsPart = scripts ? `. Scripts: ${scripts}` : "";
+        parts.push(`${prefix}${descPart}${scriptsPart}`);
+    }
+    catch {
+        // No package metadata available.
+    }
+    try {
+        const entries = fs.readdirSync(workspaceDir);
+        const dirs = entries.filter((entry) => {
+            try {
+                return fs.statSync(path.join(workspaceDir, entry)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        });
+        const files = entries.filter((entry) => {
+            try {
+                return fs.statSync(path.join(workspaceDir, entry)).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+        const visibleEntries = [
+            dirs.slice(0, 10).map((entry) => `${entry}/`).join(", "),
+            files.slice(0, 5).join(", "),
+        ].filter(Boolean).join(", ");
+        if (visibleEntries) {
+            parts.push(`Files: ${visibleEntries}`);
+        }
+    }
+    catch {
+        // Workspace listing is best-effort.
+    }
+    const gitResult = spawnSync("git", ["log", "--oneline", "-5", "--format=%s"], {
+        cwd: workspaceDir,
+        encoding: "utf-8",
+    });
+    if (gitResult.status === 0 && gitResult.stdout.trim().length > 0) {
+        parts.push(`Recent changes: ${gitResult.stdout.trim().split("\n").join("; ")}`);
+    }
+    return parts.join(". ");
+}
 // 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;
+const MAX_IDLE_SLEEP_MS = 5_000;
 export class DaemonRunner {
     coreLoop;
+    curiosityEngine;
+    goalNegotiator;
     driveSystem;
     stateManager;
     pidManager;
@@ -45,13 +125,19 @@ export class DaemonRunner {
     reportingEngine;
     cronScheduler;
     scheduleEngine;
+    memoryLifecycle;
+    knowledgeManager;
     consecutiveIdleCycles = 0;
     gateway;
     supervisor = null;
+    lastGoalReviewAt = Date.now();
     cronScheduleInterval = null;
     shutdownResolve = null;
     shutdownCoordinator = null;
     stopStatusHeartbeat = null;
+    lastRuntimeStoreMaintenanceAt = 0;
+    startupRuntimeStoreMaintenancePromise = null;
+    startupRuntimeStoreMaintenanceError = null;
     deps;
     runtimeRoot = null;
     approvalStore = null;
@@ -65,9 +151,14 @@ export class DaemonRunner {
     commandDispatcher = null;
     eventDispatcher = null;
     runtimeOwnership;
+    getProviderRuntimeFingerprintFn;
+    refreshResidentDeps;
+    providerRuntimeFingerprint = null;
     constructor(deps) {
         this.deps = deps;
         this.coreLoop = deps.coreLoop;
+        this.curiosityEngine = deps.curiosityEngine;
+        this.goalNegotiator = deps.goalNegotiator;
         this.driveSystem = deps.driveSystem;
         this.stateManager = deps.stateManager;
         this.pidManager = deps.pidManager;
@@ -77,6 +168,8 @@ export class DaemonRunner {
         this.reportingEngine = deps.reportingEngine;
         this.cronScheduler = deps.cronScheduler;
         this.scheduleEngine = deps.scheduleEngine;
+        this.memoryLifecycle = deps.memoryLifecycle;
+        this.knowledgeManager = deps.knowledgeManager;
         this.gateway = deps.gateway;
         this.supervisor = deps.supervisor ?? null;
         this.lastProactiveTickAt = Date.now();
@@ -100,11 +193,13 @@ export class DaemonRunner {
         });
         this.journalQueue = new JournalBackedQueue({
             journalPath: path.join(this.runtimeRoot, "queue.json"),
+            maxAttempts: RUNTIME_JOURNAL_MAX_ATTEMPTS,
         });
         this.queueClaimSweeper = new QueueClaimSweeper({
             queue: this.journalQueue,
         });
         this.runtimeOwnership = new RuntimeOwnershipCoordinator({
+            baseDir: this.baseDir,
             runtimeRoot: this.runtimeRoot,
             logger: this.logger,
             approvalStore: this.approvalStore,
@@ -113,6 +208,9 @@ export class DaemonRunner {
             leaderLockManager: this.leaderLockManager,
             onLeadershipLost: (reason) => this.failRuntimeLeadership(reason),
         });
+        this.getProviderRuntimeFingerprintFn =
+            deps.getProviderRuntimeFingerprint ?? getProviderRuntimeFingerprint;
+        this.refreshResidentDeps = deps.refreshResidentDeps;
         // Initialize daemon state
         this.state = DaemonStateSchema.parse({
             pid: process.pid,
@@ -123,8 +221,17 @@ export class DaemonRunner {
             status: "stopped",
             crash_count: 0,
             last_error: null,
+            last_resident_at: null,
+            resident_activity: null,
         });
     }
+    refreshOperationalState() {
+        this.state.active_goals = [...this.currentGoalIds];
+        if (this.state.status === "crashed" || this.state.status === "stopping") {
+            return;
+        }
+        this.state.status = this.currentGoalIds.length === 0 ? "idle" : "running";
+    }
     resolveRuntimeRoot() {
         const configuredRoot = this.config.runtime_root;
         if (!configuredRoot || configuredRoot.trim() === "") {
@@ -245,7 +352,9 @@ export class DaemonRunner {
             });
             this.shutdownCoordinator.activate();
             // 4. Restore state from previous interrupted run
-            const mergedGoalIds = await this.restoreState(goalIds);
+            const restoredGoalIds = await this.restoreState(goalIds);
+            const reconciledGoalIds = await this.reconcileInterruptedExecutions();
+            const mergedGoalIds = Array.from(new Set([...restoredGoalIds, ...reconciledGoalIds]));
             // 5. Save initial daemon state
             this.running = true;
             this.currentGoalIds = mergedGoalIds;
@@ -256,10 +365,13 @@ export class DaemonRunner {
                 last_loop_at: null,
                 loop_count: 0,
                 active_goals: mergedGoalIds,
-                status: "running",
+                status: mergedGoalIds.length === 0 ? "idle" : "running",
                 crash_count: 0,
                 last_error: null,
+                last_resident_at: null,
+                resident_activity: null,
             });
+            this.providerRuntimeFingerprint = await this.captureProviderRuntimeFingerprint();
             await this.saveDaemonState();
             // 5b. Write "running" shutdown marker (crash detection on next startup)
             await this.writeShutdownMarker({
@@ -298,7 +410,10 @@ export class DaemonRunner {
                     onEscalation: (goalId, crashCount, lastError) => {
                         this.logger.error(`Goal ${goalId} suspended after ${crashCount} crashes: ${lastError}`);
                     },
-                }, { iterationsPerCycle: this.config.iterations_per_cycle });
+                }, {
+                    iterationsPerCycle: this.config.iterations_per_cycle,
+                    stateFilePath: path.join(this.runtimeRoot, "supervisor-state.json"),
+                });
             }
             if (!this.eventDispatcher) {
                 this.eventDispatcher = new EventDispatcher({
@@ -313,10 +428,10 @@ export class DaemonRunner {
                 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),
+                    onGoalStart: async (goalId) => this.runCommandWithHealth("goal_start", () => this.handleGoalStartCommand(goalId)),
+                    onGoalStop: async (goalId) => this.runCommandWithHealth("goal_stop", () => this.handleGoalStopCommand(goalId)),
+                    onChatMessage: async (goalId, message) => this.runCommandWithHealth("chat_message", () => this.handleChatMessageCommand(goalId, message)),
+                    onApprovalResponse: async (goalId, requestId, approved) => this.runCommandWithHealth("approval_response", () => this.handleApprovalResponseCommand(goalId, requestId, approved)),
                 });
             }
             await this.saveRuntimeHealthSnapshot(this.supervisor
@@ -329,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;
@@ -390,7 +506,12 @@ export class DaemonRunner {
         }
         catch (err) {
             if (!startupReady) {
-                await this.releaseStartupOwnership();
+                try {
+                    await this.drainStartupRuntimeStoreMaintenance();
+                }
+                finally {
+                    await this.releaseStartupOwnership();
+                }
             }
             throw err;
         }
@@ -413,6 +534,7 @@ export class DaemonRunner {
         });
         this.state.status = "crashed";
         this.state.last_error = reason;
+        this.state.interrupted_goals = [...this.state.active_goals];
         this.running = false;
         this.shuttingDown = true;
         this.shutdownResolve?.();
@@ -455,9 +577,11 @@ export class DaemonRunner {
         while (this.running && !this.shuttingDown) {
             try {
                 const goalIds = [...this.currentGoalIds];
+                this.refreshOperationalState();
                 const cycleSnapshot = await this.collectGoalCycleSnapshot(goalIds);
                 // 1. Determine which goals need activation
                 const activeGoals = await this.determineActiveGoals(goalIds, cycleSnapshot);
+                await this.maybeRefreshProviderRuntime(activeGoals.length);
                 if (activeGoals.length === 0) {
                     this.logger.info("No goals need activation this cycle", {
                         checked: goalIds.length,
@@ -486,6 +610,7 @@ export class DaemonRunner {
                                 status: goal?.status ?? "unknown",
                             });
                         }
+                        await this.broadcastGoalUpdated(goalId, result.finalStatus);
                     }
                     catch (err) {
                         this.handleLoopError(goalId, err);
@@ -495,6 +620,7 @@ export class DaemonRunner {
                         break;
                 }
                 // 3. Save state
+                this.refreshOperationalState();
                 await this.saveDaemonState();
                 if (this.eventServer) {
                     void this.eventServer.broadcast?.("daemon_status", {
@@ -517,6 +643,9 @@ export class DaemonRunner {
                 if (this.running) {
                     await this.proactiveTick();
                 }
+                if (this.running) {
+                    await this.runRuntimeStoreMaintenance();
+                }
                 // 5. Track idle cycles for adaptive sleep
                 if (activeGoals.length > 0) {
                     this.consecutiveIdleCycles = 0;
@@ -529,8 +658,9 @@ export class DaemonRunner {
                     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);
+                    const sleepIntervalMs = activeGoals.length === 0 ? Math.min(intervalMs, MAX_IDLE_SLEEP_MS) : intervalMs;
+                    this.logger.info(`Sleeping for ${sleepIntervalMs}ms until next check`);
+                    await this.sleep(sleepIntervalMs);
                 }
             }
             catch (err) {
@@ -568,16 +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++;
-        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;
         }
     }
@@ -586,11 +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 });
-        this.state.status = "crashed";
-        this.state.last_error = msg;
-        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 ───
@@ -608,12 +739,26 @@ export class DaemonRunner {
     async restoreState(goalIds) {
         return restoreInterruptedGoals(this.baseDir, goalIds, this.logger);
     }
+    async reconcileInterruptedExecutions() {
+        return reconcileInterruptedExecutionsFn({
+            baseDir: this.baseDir,
+            stateManager: this.stateManager,
+            logger: 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() {
+        let startupMaintenanceError = null;
+        try {
+            await this.drainStartupRuntimeStoreMaintenance();
+        }
+        catch (err) {
+            startupMaintenanceError = err;
+        }
         await cleanupDaemonRun({
             baseDir: this.baseDir,
             state: this.state,
@@ -622,6 +767,9 @@ export class DaemonRunner {
             runtimeOwnership: this.runtimeOwnership,
             logger: this.logger,
         });
+        if (startupMaintenanceError) {
+            throw startupMaintenanceError;
+        }
     }
     beginGracefulShutdown() {
         if (this.shuttingDown) {
@@ -657,6 +805,28 @@ export class DaemonRunner {
             acceptRuntimeEnvelope: (envelope) => this.acceptRuntimeEnvelope(envelope),
         });
     }
+    async broadcastGoalUpdated(goalId, fallbackStatus) {
+        if (!this.eventServer) {
+            return;
+        }
+        const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+        await this.eventServer.broadcast?.("goal_updated", {
+            goalId,
+            status: goal?.status ?? fallbackStatus ?? "unknown",
+            loopStatus: goal?.loop_status ?? null,
+            progress: null,
+        });
+    }
+    async broadcastChatResponse(goalId, message) {
+        if (!this.eventServer) {
+            return;
+        }
+        await this.eventServer.broadcast?.("chat_response", {
+            goalId,
+            message,
+            status: "queued",
+        });
+    }
     /**
      * Expire old non-permanent cron tasks.
      */
@@ -717,26 +887,37 @@ export class DaemonRunner {
         if (!this.currentGoalIds.includes(goalId)) {
             this.currentGoalIds.push(goalId);
         }
-        this.state.active_goals = [...this.currentGoalIds];
+        this.refreshOperationalState();
         await this.saveDaemonState();
         this.supervisor?.activateGoal(goalId);
         this.abortSleep();
+        await this.broadcastGoalUpdated(goalId, "active");
     }
     async handleGoalStopCommand(goalId) {
         this.currentGoalIds = this.currentGoalIds.filter((id) => id !== goalId);
-        this.state.active_goals = [...this.currentGoalIds];
+        this.refreshOperationalState();
         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();
+        await this.broadcastGoalUpdated(goalId, "stopped");
     }
     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();
+        await this.runtimeOwnership.observeTaskExecution(result.status === "error"
+            ? "failed"
+            : result.status === "stalled"
+                ? "degraded"
+                : "ok", result.status === "error"
+            ? `goal ${goalId} execution failed`
+            : result.status === "stalled"
+                ? `goal ${goalId} stalled`
+                : undefined);
         if (this.eventServer) {
             const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
             void this.eventServer.broadcast?.("iteration_complete", {
@@ -752,8 +933,388 @@ export class DaemonRunner {
                 lastLoopAt: this.state.last_loop_at,
             });
         }
+        await this.broadcastGoalUpdated(goalId, result.status);
+    }
+    async loadExistingGoalTitles() {
+        const goalIds = await this.stateManager.listGoalIds().catch(() => []);
+        const titles = [];
+        for (const goalId of goalIds) {
+            const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+            if (goal?.title) {
+                titles.push(goal.title);
+            }
+        }
+        return titles;
+    }
+    async loadKnownGoals() {
+        const goalIds = await this.stateManager.listGoalIds().catch(() => []);
+        const goals = [];
+        for (const goalId of goalIds) {
+            const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+            if (goal) {
+                goals.push(goal);
+            }
+        }
+        return goals;
+    }
+    async persistResidentActivity(activity) {
+        const residentActivity = ResidentActivitySchema.parse({
+            ...activity,
+            recorded_at: activity.recorded_at ?? new Date().toISOString(),
+        });
+        this.state.last_resident_at = residentActivity.recorded_at;
+        this.state.resident_activity = residentActivity;
+        await this.saveDaemonState();
+    }
+    async triggerResidentGoalDiscovery(details) {
+        if (!this.goalNegotiator) {
+            await this.persistResidentActivity({
+                kind: "skipped",
+                trigger: "proactive_tick",
+                summary: "Resident discovery skipped because goal negotiation is unavailable.",
+            });
+            return;
+        }
+        if (this.currentGoalIds.length > 0) {
+            await this.persistResidentActivity({
+                kind: "skipped",
+                trigger: "proactive_tick",
+                summary: "Resident discovery skipped because active goals are already running.",
+            });
+            return;
+        }
+        const hintedDescription = typeof details?.["description"] === "string" ? details["description"].trim() : "";
+        const hintedTitle = typeof details?.["title"] === "string" ? details["title"].trim() : "";
+        try {
+            const workspaceDir = resolveResidentWorkspaceDir(this.config.workspace_path);
+            const workspaceContext = gatherResidentWorkspaceContext(workspaceDir, hintedDescription);
+            const existingTitles = await this.loadExistingGoalTitles();
+            const suggestions = await this.goalNegotiator.suggestGoals(workspaceContext, {
+                maxSuggestions: 1,
+                existingGoals: existingTitles,
+                repoPath: workspaceDir,
+            });
+            const suggestion = suggestions[0];
+            const suggestionTitle = suggestion?.title ?? hintedTitle;
+            const negotiationDescription = suggestion?.description ?? hintedDescription;
+            if (!negotiationDescription) {
+                await this.persistResidentActivity({
+                    kind: "suggestion",
+                    trigger: "proactive_tick",
+                    summary: "Resident discovery ran but found no actionable goal to negotiate.",
+                    suggestion_title: suggestionTitle || undefined,
+                });
+                return;
+            }
+            const { goal } = await this.goalNegotiator.negotiate(negotiationDescription, {
+                workspaceContext,
+                timeoutMs: 30_000,
+            });
+            if (!this.currentGoalIds.includes(goal.id)) {
+                this.currentGoalIds.push(goal.id);
+            }
+            this.refreshOperationalState();
+            await this.persistResidentActivity({
+                kind: "negotiation",
+                trigger: "proactive_tick",
+                summary: `Resident discovery negotiated a new goal: ${suggestionTitle || goal.title}`,
+                suggestion_title: suggestionTitle || goal.title,
+                goal_id: goal.id,
+            });
+            this.supervisor?.activateGoal(goal.id);
+            this.abortSleep();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.warn("Resident discovery failed", { error: message });
+            await this.persistResidentActivity({
+                kind: "error",
+                trigger: "proactive_tick",
+                summary: `Resident discovery failed: ${message}`,
+            });
+        }
+    }
+    async runResidentCuriosityCycle(options) {
+        if (!this.curiosityEngine) {
+            if (options?.skipWhenNoTriggers) {
+                return false;
+            }
+            await this.persistResidentActivity({
+                kind: "skipped",
+                trigger: options?.activityTrigger ?? "proactive_tick",
+                summary: "Resident investigation skipped because curiosity wiring is unavailable.",
+            });
+            return true;
+        }
+        try {
+            const goals = await this.loadKnownGoals();
+            const triggers = await this.curiosityEngine.evaluateTriggers(goals);
+            const focus = options?.focus?.trim() ?? "";
+            if (triggers.length === 0) {
+                if (options?.skipWhenNoTriggers) {
+                    return false;
+                }
+                await this.persistResidentActivity({
+                    kind: "curiosity",
+                    trigger: options?.activityTrigger ?? "proactive_tick",
+                    summary: options?.reviewLabel
+                        ? `Resident ${options.reviewLabel} ran and found no curiosity triggers.`
+                        : `Resident investigation ran${focus ? ` for ${focus}` : ""} and found nothing actionable.`,
+                });
+                return true;
+            }
+            const proposals = await this.curiosityEngine.generateProposals(triggers, goals);
+            if (proposals.length === 0) {
+                await this.persistResidentActivity({
+                    kind: "curiosity",
+                    trigger: options?.activityTrigger ?? "proactive_tick",
+                    summary: options?.reviewLabel
+                        ? `Resident ${options.reviewLabel} ran but produced no curiosity proposals.`
+                        : `Resident investigation ran${focus ? ` for ${focus}` : ""} but produced no curiosity proposals.`,
+                });
+                return true;
+            }
+            const proposal = proposals[0];
+            await this.persistResidentActivity({
+                kind: "curiosity",
+                trigger: options?.activityTrigger ?? "proactive_tick",
+                summary: options?.reviewLabel
+                    ? `Resident ${options.reviewLabel} created ${proposals.length} curiosity proposal(s); next focus: ${proposal.proposed_goal.description}`
+                    : `Resident investigation created ${proposals.length} curiosity proposal(s); next focus: ${proposal.proposed_goal.description}`,
+                suggestion_title: proposal.proposed_goal.description,
+            });
+            return true;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.warn("Resident investigation failed", { error: message });
+            await this.persistResidentActivity({
+                kind: "error",
+                trigger: options?.activityTrigger ?? "proactive_tick",
+                summary: `Resident investigation failed: ${message}`,
+            });
+            return true;
+        }
+    }
+    async triggerResidentInvestigation(details) {
+        const focus = typeof details?.["what"] === "string" ? details["what"].trim() : "";
+        await this.runResidentCuriosityCycle({
+            activityTrigger: "proactive_tick",
+            focus,
+            skipWhenNoTriggers: false,
+        });
+    }
+    async runScheduledGoalReview() {
+        if (!this.curiosityEngine || !this.config.proactive_mode) {
+            return false;
+        }
+        const now = Date.now();
+        if (now - this.lastGoalReviewAt < this.config.goal_review_interval_ms) {
+            return false;
+        }
+        this.lastGoalReviewAt = now;
+        return this.runResidentCuriosityCycle({
+            activityTrigger: "schedule",
+            reviewLabel: "goal review",
+            skipWhenNoTriggers: false,
+        });
+    }
+    async tryApplyPendingDreamSuggestion() {
+        const dreamStore = new DreamScheduleSuggestionStore(this.baseDir);
+        const pendingSuggestion = (await dreamStore.list()).find((suggestion) => suggestion.status === "pending");
+        if (!pendingSuggestion || !this.scheduleEngine) {
+            return null;
+        }
+        return dreamStore.applySuggestion(pendingSuggestion.id, this.scheduleEngine);
+    }
+    async runDreamAnalysis(tier) {
+        const analyzer = new DreamAnalyzer({
+            baseDir: this.baseDir,
+            llmClient: this.llmClient,
+            logger: this.logger,
+        });
+        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();
+            if (appliedBeforeAnalysis) {
+                await this.persistResidentActivity({
+                    kind: "dream",
+                    trigger: "proactive_tick",
+                    summary: appliedBeforeAnalysis.duplicate
+                        ? `Resident dream linked pending suggestion "${appliedBeforeAnalysis.suggestion.name ?? appliedBeforeAnalysis.suggestion.id}" to existing schedule ${appliedBeforeAnalysis.entry.id}.`
+                        : `Resident dream applied pending suggestion "${appliedBeforeAnalysis.suggestion.name ?? appliedBeforeAnalysis.suggestion.id}" into schedule ${appliedBeforeAnalysis.entry.id}.`,
+                    suggestion_title: appliedBeforeAnalysis.suggestion.name ?? appliedBeforeAnalysis.suggestion.reason,
+                });
+                return;
+            }
+            const analysisReport = await this.runDreamAnalysis(tier);
+            const appliedAfterAnalysis = tier === "deep" ? await this.tryApplyPendingDreamSuggestion() : null;
+            const platformReport = await this.runPlatformDreamConsolidation(tier);
+            const consolidationReport = tier === "deep"
+                ? this.legacyReportFromPlatformDream(platformReport) ?? await runDreamConsolidation({
+                    stateManager: this.stateManager,
+                    memoryLifecycle: this.memoryLifecycle,
+                    knowledgeManager: this.knowledgeManager,
+                    baseDir: this.baseDir,
+                })
+                : null;
+            const requestedGoalId = typeof details?.["goal_id"] === "string" ? details["goal_id"].trim() : "";
+            const goalHint = requestedGoalId ? ` for ${requestedGoalId}` : "";
+            await this.persistResidentActivity({
+                kind: "dream",
+                trigger: "proactive_tick",
+                summary: tier === "light"
+                    ? `Resident dream light analysis ran${goalHint}; processed ${analysisReport.goalsProcessed.length} goals, persisted ${analysisReport.patternsPersisted} patterns, and generated ${analysisReport.scheduleSuggestions} schedule suggestion(s).`
+                    : `Resident dream deep analysis ran${goalHint}; processed ${analysisReport.goalsProcessed.length} goals, persisted ${analysisReport.patternsPersisted} patterns, generated ${analysisReport.scheduleSuggestions} schedule suggestion(s), compressed ${consolidationReport?.entries_compressed ?? 0} entries, and created ${consolidationReport?.revalidation_tasks_created ?? 0} revalidation tasks${appliedAfterAnalysis ? ` while applying "${appliedAfterAnalysis.suggestion.name ?? appliedAfterAnalysis.suggestion.id}"` : ""}.`,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.warn("Resident dream maintenance failed", { error: message });
+            await this.persistResidentActivity({
+                kind: "error",
+                trigger: "proactive_tick",
+                summary: `Resident dream maintenance failed: ${message}`,
+            });
+        }
+    }
+    async triggerResidentPreemptiveCheck(details) {
+        const goalId = typeof details?.["goal_id"] === "string" ? details["goal_id"].trim() : "";
+        if (!goalId) {
+            await this.persistResidentActivity({
+                kind: "skipped",
+                trigger: "proactive_tick",
+                summary: "Resident preemptive check skipped because no goal_id was provided.",
+            });
+            return;
+        }
+        try {
+            const goal = await this.stateManager.loadGoal(goalId).catch(() => null);
+            if (!goal) {
+                await this.persistResidentActivity({
+                    kind: "skipped",
+                    trigger: "proactive_tick",
+                    summary: `Resident preemptive check skipped because goal "${goalId}" was not found.`,
+                    goal_id: goalId,
+                });
+                return;
+            }
+            await this.driveSystem.writeEvent(PulSeedEventSchema.parse({
+                type: "external",
+                source: "resident-proactive",
+                timestamp: new Date().toISOString(),
+                data: {
+                    event_type: "preemptive_check",
+                    goal_id: goalId,
+                    requested_by: "resident-daemon",
+                },
+            }));
+            if (!this.currentGoalIds.includes(goalId)) {
+                this.currentGoalIds.push(goalId);
+            }
+            this.refreshOperationalState();
+            this.supervisor?.activateGoal(goalId);
+            this.abortSleep();
+            await this.persistResidentActivity({
+                kind: "observation",
+                trigger: "proactive_tick",
+                summary: `Resident preemptive check queued an observation wake-up for goal "${goalId}".`,
+                goal_id: goalId,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger.warn("Resident preemptive check failed", { error: message, goal_id: goalId });
+            await this.persistResidentActivity({
+                kind: "error",
+                trigger: "proactive_tick",
+                summary: `Resident preemptive check failed: ${message}`,
+                goal_id: goalId || undefined,
+            });
+        }
+    }
+    async triggerIdleResidentMaintenance() {
+        if (this.currentGoalIds.length > 0) {
+            return;
+        }
+        const dreamSuggestionPath = path.join(this.baseDir, "dream", "schedule-suggestions.json");
+        const hasDreamSuggestionFile = fs.existsSync(dreamSuggestionPath);
+        if (!hasDreamSuggestionFile && !this.memoryLifecycle && !this.knowledgeManager && !this.llmClient) {
+            return;
+        }
+        await this.triggerResidentDreamMaintenance(undefined, "light");
     }
     async runSupervisorMaintenanceCycle() {
+        this.refreshOperationalState();
+        await this.maybeRefreshProviderRuntime((this.supervisor?.getState().workers ?? []).filter((worker) => worker.goalId !== null).length);
         await runSupervisorMaintenanceCycleForDaemon({
             currentGoalIds: this.currentGoalIds,
             driveSystem: this.driveSystem,
@@ -764,12 +1325,58 @@ export class DaemonRunner {
             saveDaemonState: () => this.saveDaemonState(),
             eventServer: this.eventServer,
             state: this.state,
+            runRuntimeStoreMaintenance: () => this.runRuntimeStoreMaintenance(),
         });
     }
+    async captureProviderRuntimeFingerprint() {
+        try {
+            return await this.getProviderRuntimeFingerprintFn();
+        }
+        catch (error) {
+            this.logger.warn("Failed to capture provider runtime fingerprint", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    async maybeRefreshProviderRuntime(activeGoalCount) {
+        if (!this.refreshResidentDeps || activeGoalCount > 0) {
+            return;
+        }
+        const currentFingerprint = await this.captureProviderRuntimeFingerprint();
+        if (!currentFingerprint || currentFingerprint === this.providerRuntimeFingerprint) {
+            return;
+        }
+        try {
+            const freshDeps = await this.refreshResidentDeps();
+            this.coreLoop = freshDeps.coreLoop;
+            this.curiosityEngine = freshDeps.curiosityEngine;
+            this.goalNegotiator = freshDeps.goalNegotiator;
+            this.llmClient = freshDeps.llmClient;
+            this.reportingEngine = freshDeps.reportingEngine;
+            this.scheduleEngine = freshDeps.scheduleEngine;
+            this.memoryLifecycle = freshDeps.memoryLifecycle;
+            this.knowledgeManager = freshDeps.knowledgeManager;
+            this.supervisor?.replaceIdleWorkers(() => this.coreLoop);
+            this.providerRuntimeFingerprint = currentFingerprint;
+            this.logger.info("Refreshed resident daemon dependencies after provider drift", {
+                fingerprint_changed: true,
+            });
+        }
+        catch (error) {
+            this.logger.warn("Failed to refresh resident daemon dependencies after provider drift", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
     async handleChatMessageCommand(goalId, message) {
         await writeChatMessageEvent(this.driveSystem, goalId, message);
+        await this.broadcastChatResponse(goalId, message);
         this.abortSleep();
     }
+    async runCommandWithHealth(commandName, fn) {
+        return runCommandWithHealthFn(commandName, fn, (status, reason) => this.runtimeOwnership.observeCommandAcceptance(status, reason));
+    }
     async handleApprovalResponseCommand(goalId, requestId, approved) {
         if (this.approvalBroker) {
             await this.approvalBroker.resolveApproval(requestId, approved, "dispatcher");
@@ -794,6 +1401,50 @@ export class DaemonRunner {
             await this.cronScheduler.markFired(taskId);
         }
     }
+    async runRuntimeStoreMaintenance(force = false) {
+        if (!this.runtimeRoot) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - this.lastRuntimeStoreMaintenanceAt < this.config.check_interval_ms) {
+            return;
+        }
+        this.lastRuntimeStoreMaintenanceAt = now;
+        await runRuntimeStoreMaintenanceCycle({
+            runtimeRoot: this.runtimeRoot,
+            approvalStore: this.approvalStore ?? undefined,
+            outboxStore: this.outboxStore ?? undefined,
+            runtimeHealthStore: this.runtimeHealthStore ?? undefined,
+            logger: this.logger,
+            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.
@@ -801,13 +1452,56 @@ export class DaemonRunner {
      * Errors are caught and logged — they never affect the daemon loop.
      */
     async proactiveTick() {
-        this.lastProactiveTickAt = await runProactiveMaintenance({
+        if (!this.config.proactive_mode) {
+            return;
+        }
+        if (await this.runScheduledGoalReview()) {
+            return;
+        }
+        const curiosityTriggered = await this.runResidentCuriosityCycle({
+            activityTrigger: "proactive_tick",
+            skipWhenNoTriggers: true,
+        });
+        if (curiosityTriggered) {
+            return;
+        }
+        const result = await runProactiveMaintenance({
             config: this.config,
             llmClient: this.llmClient,
             state: this.state,
             lastProactiveTickAt: this.lastProactiveTickAt,
             logger: this.logger,
         });
+        this.lastProactiveTickAt = result.lastProactiveTickAt;
+        if (!result.decision) {
+            return;
+        }
+        if (result.decision.action === "sleep") {
+            await this.persistResidentActivity({
+                kind: "sleep",
+                trigger: "proactive_tick",
+                summary: "Resident proactive tick stayed idle.",
+            });
+            await this.triggerIdleResidentMaintenance();
+            return;
+        }
+        if (result.decision.action === "suggest_goal") {
+            await this.triggerResidentGoalDiscovery(result.decision.details);
+            return;
+        }
+        if (result.decision.action === "investigate") {
+            await this.triggerResidentInvestigation(result.decision.details);
+            return;
+        }
+        if (result.decision.action === "preemptive_check") {
+            await this.triggerResidentPreemptiveCheck(result.decision.details);
+            return;
+        }
+        await this.persistResidentActivity({
+            kind: "skipped",
+            trigger: "proactive_tick",
+            summary: `Resident proactive tick requested ${result.decision.action}, but no resident executor is wired for it yet.`,
+        });
     }
     // ─── Private: Adaptive Sleep ───
     /**