pulseed 0.4.3 → 0.4.4

package/dist/runtime/daemon/runner.js

@@ -1,6 +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 } from "../../base/types/daemon.js";
+import { DaemonConfigSchema, DaemonStateSchema, ResidentActivitySchema } from "../../base/types/daemon.js";
+import { DreamAnalyzer } from "../../platform/dream/dream-analyzer.js";
+import { DreamScheduleSuggestionStore } from "../../platform/dream/dream-schedule-suggestions.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";
@@ -16,14 +25,81 @@ 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 { 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 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 +121,17 @@ 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;
     deps;
     runtimeRoot = null;
     approvalStore = null;
@@ -65,9 +145,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 +162,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 +187,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 +202,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 +215,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() === "") {
@@ -147,6 +248,7 @@ 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;
@@ -245,7 +347,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 +360,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 +405,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 +423,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
@@ -413,6 +523,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 +566,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 +599,7 @@ export class DaemonRunner {
                                 status: goal?.status ?? "unknown",
                             });
                         }
+                        await this.broadcastGoalUpdated(goalId, result.finalStatus);
                     }
                     catch (err) {
                         this.handleLoopError(goalId, err);
@@ -495,6 +609,7 @@ export class DaemonRunner {
                         break;
                 }
                 // 3. Save state
+                this.refreshOperationalState();
                 await this.saveDaemonState();
                 if (this.eventServer) {
                     void this.eventServer.broadcast?.("daemon_status", {
@@ -517,6 +632,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 +647,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) {
@@ -570,6 +689,7 @@ export class DaemonRunner {
     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,
@@ -588,8 +708,10 @@ export class DaemonRunner {
     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();
         this.running = false;
     }
@@ -608,6 +730,145 @@ export class DaemonRunner {
     async restoreState(goalIds) {
         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,
+        });
+        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 ───
     /**
      * Perform cleanup after the loop exits and write the final runtime health snapshot.
@@ -657,6 +918,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 +1000,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 +1046,321 @@ 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 = process.cwd();
+            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 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 consolidationReport = tier === "deep"
+                ? 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 +1371,67 @@ 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) {
+        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;
+        }
+    }
     async handleApprovalResponseCommand(goalId, requestId, approved) {
         if (this.approvalBroker) {
             await this.approvalBroker.resolveApproval(requestId, approved, "dispatcher");
@@ -794,6 +1456,24 @@ 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,
+        });
+    }
     // ─── Private: Proactive Tick ───
     /**
      * Ask the LLM for a proactive action when no goals were activated this cycle.
@@ -801,13 +1481,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 ───
     /**