gnosys 5.11.4 → 5.12.2

package/dist/lib/dream.js

@@ -18,10 +18,12 @@
  *   - Uses cheap/local LLM (configurable, defaults to Ollama)
  */
 import os from "os";
-import { getLLMProvider } from "./llm.js";
+import { getProviderModel } from "./config.js";
+import { createProvider } from "./llm.js";
 import { notifyDesktop } from "./desktopNotify.js";
 import { syncConfidenceToDb, auditToDb } from "./dbWrite.js";
 import { logError } from "./log.js";
+import { estimateCost, acquireDreamLock, estimateTokens, fingerprintMemories, memoryWatermark, readDreamState, writeDreamState, } from "./dreamRunLog.js";
 /** Layer 4 alert threshold: fire desktop notification at this many consecutive provider failures. */
 const DREAM_FAILURE_NOTIFY_THRESHOLD = 3;
 export const DEFAULT_DREAM_CONFIG = {
@@ -34,6 +36,11 @@ export const DEFAULT_DREAM_CONFIG = {
     generateSummaries: true,
     discoverRelationships: true,
     minMemories: 10,
+    schedule: { startHour: 2, endHour: 5 },
+    systemIdleMinutes: 30,
+    minNewMemoriesToDream: 10,
+    minHoursBetweenRuns: 20,
+    maxLLMCallsPerRun: 12,
 };
 // ─── Decay Constants ─────────────────────────────────────────────────────
 const DECAY_LAMBDA = 0.005;
@@ -46,16 +53,37 @@ export class GnosysDreamEngine {
     provider = null;
     abortRequested = false;
     startTime = 0;
-    constructor(db, config, dreamConfig) {
+    trigger;
+    machineId;
+    dreamState = readDreamState();
+    pendingFingerprints = {};
+    llmCallsMade = 0;
+    constructor(db, config, dreamConfig, options) {
         this.db = db;
         this.config = config;
-        this.dreamConfig = { ...DEFAULT_DREAM_CONFIG, ...dreamConfig };
+        this.dreamConfig = {
+            ...DEFAULT_DREAM_CONFIG,
+            ...dreamConfig,
+            schedule: { ...DEFAULT_DREAM_CONFIG.schedule, ...(dreamConfig?.schedule ?? {}) },
+        };
+        this.trigger = options?.trigger ?? "manual";
+        this.machineId = options?.machineId;
         // Initialize LLM provider for dream operations.
         // v5.4.2: Failure here is no longer silent — when dream tries to actually
         // run (in dream()), we record the unavailability to audit_log so the
         // user gets visibility (Layer 2 alert) and can react via the dashboard.
         try {
-            this.provider = getLLMProvider(this.config, "structuring");
+            const provider = this.dreamConfig.provider;
+            let model = this.dreamConfig.model;
+            if (!model) {
+                try {
+                    model = getProviderModel(this.config, provider);
+                }
+                catch {
+                    model = "";
+                }
+            }
+            this.provider = createProvider(provider, model, this.config);
         }
         catch (err) {
             this.provider = null;
@@ -64,6 +92,136 @@ export class GnosysDreamEngine {
     }
     /** Captured at construction if getLLMProvider throws. Used in dream() to write a Layer 2 audit entry. */
     providerInitError = null;
+    createPhase(name) {
+        return {
+            name,
+            status: "ran",
+            durationMs: 0,
+            memoryIdsTouched: [],
+            llmCallsMade: 0,
+            llmCallsSkipped: 0,
+            estimatedInputTokens: 0,
+            estimatedOutputTokens: 0,
+            estimatedCostUsd: 0,
+        };
+    }
+    finishPhase(phase, startedAtMs) {
+        phase.durationMs = Date.now() - startedAtMs;
+        phase.memoryIdsTouched = Array.from(new Set(phase.memoryIdsTouched));
+        phase.estimatedCostUsd = Math.round(phase.estimatedCostUsd * 1_000_000) / 1_000_000;
+        this.checkpointFingerprints();
+    }
+    /**
+     * v5.12.1 crash safety: persist analyzed fingerprints at every phase
+     * boundary, not only in finalize(). A crash mid-run previously lost all
+     * pendingFingerprints, so the next run re-analyzed (and re-paid for) the
+     * same memory sets and could double-create summaries. Checkpointing only
+     * merges fingerprints — lastRunAt / watermarks remain finalize()'s job.
+     */
+    checkpointFingerprints() {
+        if (Object.keys(this.pendingFingerprints).length === 0)
+            return;
+        try {
+            writeDreamState({
+                ...this.dreamState,
+                analyzedFingerprints: {
+                    ...this.dreamState.analyzedFingerprints,
+                    ...this.pendingFingerprints,
+                },
+            });
+        }
+        catch {
+            // Best-effort: a failed checkpoint only costs re-analysis on resume.
+        }
+    }
+    addTouched(phase, memoryIds) {
+        for (const id of memoryIds) {
+            if (id)
+                phase.memoryIdsTouched.push(id);
+        }
+    }
+    recordLLMSkip(phase, label, reason, memoryIds = [], fingerprint) {
+        phase.llmCallsSkipped++;
+        this.llmCalls.push({
+            phase: phase.name,
+            label,
+            status: "skipped",
+            reason,
+            provider: this.dreamConfig.provider,
+            model: this.dreamConfig.model || this.provider?.model || getProviderModel(this.config, this.dreamConfig.provider),
+            memoryIds,
+            fingerprint,
+            estimatedInputTokens: 0,
+            estimatedOutputTokens: 0,
+            estimatedCostUsd: 0,
+        });
+    }
+    llmCalls = [];
+    async generateWithAccounting(phase, label, prompt, maxTokens, memoryIds, fingerprint) {
+        if (!this.provider) {
+            this.recordLLMSkip(phase, label, "provider unavailable", memoryIds, fingerprint);
+            return null;
+        }
+        if (fingerprint && (this.dreamState.analyzedFingerprints[fingerprint] || this.pendingFingerprints[fingerprint])) {
+            this.recordLLMSkip(phase, label, "already analyzed fingerprint", memoryIds, fingerprint);
+            return null;
+        }
+        if (this.llmCallsMade >= this.dreamConfig.maxLLMCallsPerRun) {
+            this.recordLLMSkip(phase, label, "maxLLMCallsPerRun reached", memoryIds, fingerprint);
+            return null;
+        }
+        const inputTokens = estimateTokens(prompt);
+        this.llmCallsMade++;
+        try {
+            const response = await this.provider.generate(prompt, { maxTokens });
+            const outputTokens = estimateTokens(response);
+            const cost = estimateCost(this.provider.model, inputTokens, outputTokens);
+            phase.llmCallsMade++;
+            phase.estimatedInputTokens += inputTokens;
+            phase.estimatedOutputTokens += outputTokens;
+            phase.estimatedCostUsd += cost;
+            this.llmCalls.push({
+                phase: phase.name,
+                label,
+                status: "made",
+                provider: this.provider.name,
+                model: this.provider.model,
+                memoryIds,
+                fingerprint,
+                estimatedInputTokens: inputTokens,
+                estimatedOutputTokens: outputTokens,
+                estimatedCostUsd: cost,
+            });
+            if (fingerprint && response) {
+                this.pendingFingerprints[fingerprint] = {
+                    kind: phase.name === "relationships" ? "relationship" : phase.name === "summaries" ? "summary" : "critique",
+                    lastAnalyzedAt: new Date().toISOString(),
+                    memoryIds,
+                };
+            }
+            return response;
+        }
+        catch (err) {
+            phase.llmCallsMade++;
+            const cost = estimateCost(this.provider.model, inputTokens, 0);
+            phase.estimatedInputTokens += inputTokens;
+            phase.estimatedCostUsd += cost;
+            this.llmCalls.push({
+                phase: phase.name,
+                label,
+                status: "failed",
+                reason: err instanceof Error ? err.message : String(err),
+                provider: this.provider.name,
+                model: this.provider.model,
+                memoryIds,
+                fingerprint,
+                estimatedInputTokens: inputTokens,
+                estimatedOutputTokens: 0,
+                estimatedCostUsd: cost,
+            });
+            throw err;
+        }
+    }
     /** Expose the local DB so DreamScheduler can read designation meta. */
     getDb() {
         return this.db;
@@ -100,9 +258,16 @@ export class GnosysDreamEngine {
     async dream(onProgress) {
         this.startTime = Date.now();
         this.abortRequested = false;
+        this.llmCallsMade = 0;
+        this.llmCalls = [];
+        this.pendingFingerprints = {};
+        this.dreamState = readDreamState();
         const log = onProgress || (() => { });
+        const startedAt = new Date().toISOString();
         const report = {
-            startedAt: new Date().toISOString(),
+            id: `dream-${Date.parse(startedAt)}-${Math.random().toString(36).slice(2, 8)}`,
+            trigger: this.trigger,
+            startedAt,
             finishedAt: "",
             durationMs: 0,
             decayUpdated: 0,
@@ -113,6 +278,27 @@ export class GnosysDreamEngine {
             duplicatesFound: 0,
             errors: [],
             aborted: false,
+            machine: { hostname: os.hostname(), machineId: this.machineId },
+            provider: this.dreamConfig.provider,
+            model: this.dreamConfig.model || this.provider?.model,
+            phases: [],
+            llmCalls: [],
+            totals: {
+                llmCallsMade: 0,
+                llmCallsSkipped: 0,
+                estimatedInputTokens: 0,
+                estimatedOutputTokens: 0,
+                estimatedCostUsd: 0,
+            },
+            effectiveness: {
+                usefulOutputScore: 0,
+                costPerUsefulOutput: null,
+                decaysApplied: 0,
+                summariesGenerated: 0,
+                summariesUpdated: 0,
+                reviewSuggestions: 0,
+                relationshipsDiscovered: 0,
+            },
         };
         if (!this.db.isAvailable() || !this.db.isMigrated()) {
             report.errors.push("gnosys.db not available or not migrated");
@@ -161,13 +347,21 @@ export class GnosysDreamEngine {
         }
         // ─── Phase 1: Confidence Decay Sweep ─────────────────────────────────
         log("decay", "Phase 1: Confidence decay sweep...");
+        const decayPhase = this.createPhase("decay");
+        const decayStart = Date.now();
+        report.phases.push(decayPhase);
         try {
-            report.decayUpdated = this.decaySweep();
+            const decayResult = this.decaySweep();
+            report.decayUpdated = decayResult.count;
+            this.addTouched(decayPhase, decayResult.memoryIds);
             log("decay", `Updated ${report.decayUpdated} memories`);
         }
         catch (err) {
             report.errors.push(`Decay sweep: ${err instanceof Error ? err.message : String(err)}`);
         }
+        finally {
+            this.finishPhase(decayPhase, decayStart);
+        }
         let check = this.shouldStop();
         if (check.stop) {
             report.aborted = true;
@@ -177,13 +371,20 @@ export class GnosysDreamEngine {
         // ─── Phase 2: Self-Critique (Review Suggestions) ─────────────────────
         if (this.dreamConfig.selfCritique) {
             log("critique", "Phase 2: Self-critique...");
+            const critiquePhase = this.createPhase("critique");
+            const critiqueStart = Date.now();
+            report.phases.push(critiquePhase);
             try {
-                report.reviewSuggestions = await this.selfCritique(log);
+                report.reviewSuggestions = await this.selfCritique(log, critiquePhase);
+                this.addTouched(critiquePhase, report.reviewSuggestions.map((s) => s.memoryId));
                 log("critique", `Generated ${report.reviewSuggestions.length} review suggestions`);
             }
             catch (err) {
                 report.errors.push(`Self-critique: ${err instanceof Error ? err.message : String(err)}`);
             }
+            finally {
+                this.finishPhase(critiquePhase, critiqueStart);
+            }
             check = this.shouldStop();
             if (check.stop) {
                 report.aborted = true;
@@ -194,15 +395,22 @@ export class GnosysDreamEngine {
         // ─── Phase 3: Summary Generation ─────────────────────────────────────
         if (this.dreamConfig.generateSummaries && this.provider) {
             log("summaries", "Phase 3: Summary generation...");
+            const summariesPhase = this.createPhase("summaries");
+            const summariesStart = Date.now();
+            report.phases.push(summariesPhase);
             try {
-                const summaryResult = await this.generateSummaries(log);
+                const summaryResult = await this.generateSummaries(log, summariesPhase);
                 report.summariesGenerated = summaryResult.generated;
                 report.summariesUpdated = summaryResult.updated;
+                this.addTouched(summariesPhase, summaryResult.memoryIds);
                 log("summaries", `Generated ${summaryResult.generated}, updated ${summaryResult.updated}`);
             }
             catch (err) {
                 report.errors.push(`Summary generation: ${err instanceof Error ? err.message : String(err)}`);
             }
+            finally {
+                this.finishPhase(summariesPhase, summariesStart);
+            }
             check = this.shouldStop();
             if (check.stop) {
                 report.aborted = true;
@@ -213,19 +421,73 @@ export class GnosysDreamEngine {
         // ─── Phase 4: Relationship Discovery ─────────────────────────────────
         if (this.dreamConfig.discoverRelationships && this.provider) {
             log("relationships", "Phase 4: Relationship discovery...");
+            const relationshipsPhase = this.createPhase("relationships");
+            const relationshipsStart = Date.now();
+            report.phases.push(relationshipsPhase);
             try {
-                report.relationshipsDiscovered = await this.discoverRelationships(log);
+                const relationshipsResult = await this.discoverRelationships(log, relationshipsPhase);
+                report.relationshipsDiscovered = relationshipsResult.count;
+                this.addTouched(relationshipsPhase, relationshipsResult.memoryIds);
                 log("relationships", `Discovered ${report.relationshipsDiscovered} new relationships`);
             }
             catch (err) {
                 report.errors.push(`Relationship discovery: ${err instanceof Error ? err.message : String(err)}`);
             }
+            finally {
+                this.finishPhase(relationshipsPhase, relationshipsStart);
+            }
         }
         return this.finalize(report);
     }
     finalize(report) {
         report.finishedAt = new Date().toISOString();
         report.durationMs = Date.now() - this.startTime;
+        report.llmCalls = this.llmCalls;
+        report.totals = this.llmCalls.reduce((totals, call) => {
+            if (call.status === "made" || call.status === "failed")
+                totals.llmCallsMade++;
+            if (call.status === "skipped")
+                totals.llmCallsSkipped++;
+            totals.estimatedInputTokens += call.estimatedInputTokens;
+            totals.estimatedOutputTokens += call.estimatedOutputTokens;
+            totals.estimatedCostUsd += call.estimatedCostUsd;
+            return totals;
+        }, {
+            llmCallsMade: 0,
+            llmCallsSkipped: 0,
+            estimatedInputTokens: 0,
+            estimatedOutputTokens: 0,
+            estimatedCostUsd: 0,
+        });
+        report.totals.estimatedCostUsd = Math.round(report.totals.estimatedCostUsd * 1_000_000) / 1_000_000;
+        const usefulOutputScore = report.decayUpdated +
+            report.summariesGenerated * 5 +
+            report.summariesUpdated * 3 +
+            report.relationshipsDiscovered * 2;
+        report.effectiveness = {
+            usefulOutputScore,
+            costPerUsefulOutput: usefulOutputScore > 0
+                ? Math.round((report.totals.estimatedCostUsd / usefulOutputScore) * 1_000_000) / 1_000_000
+                : null,
+            decaysApplied: report.decayUpdated,
+            summariesGenerated: report.summariesGenerated,
+            summariesUpdated: report.summariesUpdated,
+            reviewSuggestions: report.reviewSuggestions.length,
+            relationshipsDiscovered: report.relationshipsDiscovered,
+        };
+        const memories = this.db.isAvailable() ? this.db.getActiveMemories() : [];
+        const watermark = memoryWatermark(memories);
+        writeDreamState({
+            ...this.dreamState,
+            lastRunAt: report.finishedAt,
+            lastSuccessfulRunAt: report.errors.length === 0 && !report.aborted ? report.finishedAt : this.dreamState.lastSuccessfulRunAt,
+            lastMemoryCount: watermark.count,
+            lastMemoryMaxModified: watermark.maxModified,
+            analyzedFingerprints: {
+                ...this.dreamState.analyzedFingerprints,
+                ...this.pendingFingerprints,
+            },
+        });
         // v5.4.2: A run is considered "successful with LLM work" if any of the
         // LLM-dependent counters moved. Resetting the consecutive-failure count
         // here ensures Layer 4 doesn't keep firing once dream is healthy again.
@@ -241,6 +503,10 @@ export class GnosysDreamEngine {
             summariesGenerated: report.summariesGenerated,
             reviewSuggestions: report.reviewSuggestions.length,
             relationshipsDiscovered: report.relationshipsDiscovered,
+            llmCallsMade: report.totals.llmCallsMade,
+            llmCallsSkipped: report.totals.llmCallsSkipped,
+            estimatedCostUsd: report.totals.estimatedCostUsd,
+            usefulOutputScore: report.effectiveness.usefulOutputScore,
             errors: report.errors.length,
             aborted: report.aborted,
             providerUnreachable: !this.provider,
@@ -257,9 +523,9 @@ export class GnosysDreamEngine {
      */
     decaySweep() {
         const now = new Date();
-        const today = now.toISOString().split("T")[0];
         const memories = this.db.getActiveMemories();
         let updated = 0;
+        const memoryIds = [];
         for (const mem of memories) {
             const lastReinforced = mem.last_reinforced || mem.modified || mem.created;
             const lastDate = new Date(lastReinforced);
@@ -272,16 +538,17 @@ export class GnosysDreamEngine {
             if (Math.abs(rounded - mem.confidence) > 0.01) {
                 syncConfidenceToDb(this.db, mem.id, rounded);
                 updated++;
+                memoryIds.push(mem.id);
             }
         }
-        return updated;
+        return { count: updated, memoryIds };
     }
     // ─── Phase 2: Self-Critique ────────────────────────────────────────────
     /**
      * Score memories and generate review suggestions.
      * NEVER deletes or archives — only flags for human review.
      */
-    async selfCritique(log) {
+    async selfCritique(log, phase) {
         const suggestions = [];
         const memories = this.db.getActiveMemories();
         for (const mem of memories) {
@@ -308,7 +575,7 @@ export class GnosysDreamEngine {
                 if (check.stop)
                     break;
                 try {
-                    const llmSuggestion = await this.llmCritique(mem);
+                    const llmSuggestion = await this.llmCritique(mem, phase);
                     if (llmSuggestion) {
                         suggestions.push(llmSuggestion);
                     }
@@ -374,9 +641,10 @@ export class GnosysDreamEngine {
     /**
      * LLM-based critique for borderline memories.
      */
-    async llmCritique(mem) {
+    async llmCritique(mem, phase) {
         if (!this.provider)
             return null;
+        const fingerprint = fingerprintMemories("critique", [mem]);
         const prompt = `You are a knowledge management quality reviewer. Evaluate this memory and decide if it needs attention.
 
 Title: ${mem.title}
@@ -395,7 +663,9 @@ Respond with ONLY one of these JSON objects (no explanation):
 - {"action": "needs-update", "reason": "..."} if content seems outdated
 - {"action": "consider-merge", "reason": "..."} if it seems to overlap with other common knowledge`;
         try {
-            const response = await this.provider.generate(prompt, { maxTokens: 200 });
+            const response = await this.generateWithAccounting(phase, `critique:${mem.id}`, prompt, 200, [mem.id], fingerprint);
+            if (!response)
+                return null;
             const jsonMatch = response.match(/\{[^}]+\}/);
             if (!jsonMatch)
                 return null;
@@ -429,12 +699,13 @@ Respond with ONLY one of these JSON objects (no explanation):
      * Generate or update hierarchical summaries per category.
      * Uses LLM to synthesize category-level overviews.
      */
-    async generateSummaries(log) {
+    async generateSummaries(log, phase) {
         if (!this.provider)
-            return { generated: 0, updated: 0 };
+            return { generated: 0, updated: 0, memoryIds: [] };
         const categories = this.db.getCategories();
         let generated = 0;
         let updated = 0;
+        const touched = [];
         for (const category of categories) {
             const check = this.shouldStop();
             if (check.stop)
@@ -449,12 +720,15 @@ Respond with ONLY one of these JSON objects (no explanation):
                 const currentIds = memories.map((m) => m.id);
                 const unchanged = existingIds.length === currentIds.length &&
                     existingIds.every((id) => currentIds.includes(id));
-                if (unchanged)
+                if (unchanged) {
+                    phase.llmCallsSkipped++;
+                    phase.reason = phase.reason || "unchanged summaries skipped";
                     continue; // No new memories in this category
+                }
             }
             log("summaries", `Summarizing ${category} (${memories.length} memories)...`);
             try {
-                const summary = await this.summarizeCategory(category, memories);
+                const summary = await this.summarizeCategory(category, memories, phase);
                 if (summary) {
                     const today = new Date().toISOString().split("T")[0];
                     const id = existing?.id || `summary-${category}-${today}`;
@@ -473,18 +747,19 @@ Respond with ONLY one of these JSON objects (no explanation):
                     else {
                         generated++;
                     }
+                    touched.push(...memories.map((m) => m.id));
                 }
             }
             catch (err) {
                 log("summaries", `Failed to summarize ${category}: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        return { generated, updated };
+        return { generated, updated, memoryIds: touched };
     }
     /**
      * Use LLM to generate a category summary.
      */
-    async summarizeCategory(category, memories) {
+    async summarizeCategory(category, memories, phase) {
         if (!this.provider)
             return null;
         // Build context from memories (truncate to fit context window)
@@ -506,7 +781,7 @@ ${memoryTexts}
 
 Category summary:`;
         try {
-            return await this.provider.generate(prompt, { maxTokens: 1024 });
+            return await this.generateWithAccounting(phase, `summary:${category}`, prompt, 1024, memories.map((m) => m.id), fingerprintMemories("summary", memories));
         }
         catch {
             return null;
@@ -517,13 +792,14 @@ Category summary:`;
      * Use LLM to discover relationships between memories.
      * Only creates new edges — never removes existing ones.
      */
-    async discoverRelationships(log) {
+    async discoverRelationships(log, phase) {
         if (!this.provider)
-            return 0;
+            return { count: 0, memoryIds: [] };
         const memories = this.db.getActiveMemories();
         if (memories.length < 3)
-            return 0;
+            return { count: 0, memoryIds: [] };
         let discovered = 0;
+        const touched = new Set();
         const today = new Date().toISOString().split("T")[0];
         // Get existing relationships to avoid duplicates
         const existingPairs = new Set();
@@ -548,7 +824,7 @@ Category summary:`;
             const batchTitles = batch.map((m) => `[${m.id}] ${m.title}`).join(", ");
             log("relationships", `Analyzing relationships for: ${batchTitles}`);
             try {
-                const relationships = await this.findRelationships(batch, memoryIndex);
+                const relationships = await this.findRelationships(batch, memoryIndex, phase);
                 for (const rel of relationships) {
                     const key = `${rel.source_id}→${rel.target_id}→${rel.rel_type}`;
                     if (existingPairs.has(key))
@@ -563,18 +839,20 @@ Category summary:`;
                     });
                     existingPairs.add(key);
                     discovered++;
+                    touched.add(rel.source_id);
+                    touched.add(rel.target_id);
                 }
             }
             catch (err) {
                 log("relationships", `Failed for batch: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        return discovered;
+        return { count: discovered, memoryIds: Array.from(touched) };
     }
     /**
      * Use LLM to find relationships for a batch of source memories.
      */
-    async findRelationships(sources, memoryIndex) {
+    async findRelationships(sources, memoryIndex, phase) {
         if (!this.provider)
             return [];
         const sourceContext = sources
@@ -594,7 +872,9 @@ For each relationship found, output a JSON array of objects with: source_id, tar
 Only output relationships with confidence >= 0.7. Do NOT create self-referencing relationships.
 Output ONLY the JSON array, no explanation.`;
         try {
-            const response = await this.provider.generate(prompt, { maxTokens: 1024 });
+            const response = await this.generateWithAccounting(phase, `relationships:${sources.map((s) => s.id).join(",")}`, prompt, 1024, sources.map((s) => s.id), fingerprintMemories("relationship", sources));
+            if (!response)
+                return [];
             // Extract JSON array from response
             const jsonMatch = response.match(/\[[\s\S]*\]/);
             if (!jsonMatch)
@@ -730,6 +1010,15 @@ export class DreamScheduler {
         const idleMs = Date.now() - this.lastActivity;
         const idleMinutes = idleMs / 60_000;
         if (idleMinutes >= this.config.idleMinutes) {
+            // v5.12.1: the in-memory `running` flag does not survive a sandbox
+            // restart and cannot see a concurrent manual `gnosys dream`. Tie the
+            // scheduler to the same cross-process file lock the CLI uses.
+            const lock = acquireDreamLock();
+            if (!lock.acquired) {
+                console.error(`[dream] scheduler skipped: ${lock.reason}`);
+                this.lastActivity = Date.now(); // back off a full idle window
+                return;
+            }
             this.running = true;
             try {
                 this.currentDream = this.engine.dream((phase, detail) => {
@@ -746,6 +1035,7 @@ export class DreamScheduler {
                 this.running = false;
                 this.currentDream = null;
                 this.lastActivity = Date.now(); // Reset idle timer after dream
+                lock.release();
             }
         }
     }
@@ -769,7 +1059,7 @@ export function formatDreamReport(report) {
     lines.push(`Started: ${report.startedAt}`);
     lines.push(`Finished: ${report.finishedAt}`);
     if (report.aborted) {
-        lines.push(`⚠ Aborted: ${report.abortReason}`);
+        lines.push(`Aborted: ${report.abortReason}`);
     }
     lines.push("");
     lines.push("Results:");
@@ -778,6 +1068,10 @@ export function formatDreamReport(report) {
     lines.push(`  Summaries updated: ${report.summariesUpdated}`);
     lines.push(`  Relationships discovered: ${report.relationshipsDiscovered}`);
     lines.push(`  Duplicates flagged: ${report.duplicatesFound}`);
+    if (report.totals) {
+        lines.push(`  LLM calls: ${report.totals.llmCallsMade} made, ${report.totals.llmCallsSkipped} skipped`);
+        lines.push(`  Estimated cost: $${report.totals.estimatedCostUsd.toFixed(6)}`);
+    }
     lines.push("");
     if (report.reviewSuggestions.length > 0) {
         lines.push(`Review Suggestions (${report.reviewSuggestions.length}):`);

package/dist/lib/dreamCommand.d.ts

@@ -0,0 +1,10 @@
+export type DreamCommandOptions = {
+    maxRuntime?: string;
+    critique?: boolean;
+    summaries?: boolean;
+    relationships?: boolean;
+    json?: boolean;
+    force?: boolean;
+    scheduled?: boolean;
+};
+export declare function runDreamCommand(opts: DreamCommandOptions): Promise<void>;