pulseed 0.4.4 → 0.4.6

package/dist/platform/dream/dream-consolidator.js

@@ -1,8 +1,11 @@
 import * as fsp from "node:fs/promises";
 import * as path from "node:path";
-import { writeJsonFileAtomic } from "../../base/utils/json-io.js";
+import { createHash } from "node:crypto";
+import { readJsonFileOrNull, writeJsonFileAtomic } from "../../base/utils/json-io.js";
+import { upsertDreamActivationArtifacts, loadDreamActivationArtifacts } from "./dream-activation-artifacts.js";
+import { consolidateDreamEventWorkflows, loadDreamWorkflowRecords } from "./dream-event-workflows.js";
 import { DEFAULT_DREAM_CONFIG } from "./dream-config.js";
-import { ConsolidationCategoryResultSchema, DreamReportSchema, } from "./dream-types.js";
+import { ConsolidationCategoryResultSchema, DreamActivationArtifactSchema, DreamOperationalReportSchema, DreamReportSchema, WatermarkStateSchema, } from "./dream-types.js";
 const LIGHT_CATEGORIES = [
     "memory",
     "agentMemory",
@@ -23,12 +26,15 @@ const DEEP_CATEGORIES = [
     "strategyHistory",
     "verificationArtifacts",
     "archive",
+    "legacyReflectionCompatibility",
     "knowledgeOptimization",
 ];
 export class DreamConsolidator {
     deps;
     logger;
     config;
+    passRegistry;
+    activationArtifactsWritten = 0;
     constructor(deps) {
         this.deps = deps;
         this.logger = deps.logger;
@@ -36,8 +42,10 @@ export class DreamConsolidator {
             ...DEFAULT_DREAM_CONFIG.consolidation,
             ...deps.config,
         };
+        this.passRegistry = this.buildPassRegistry();
     }
     async run(options = {}) {
+        this.activationArtifactsWritten = 0;
         const tier = options.tier ?? "deep";
         const categories = tier === "light" ? LIGHT_CATEGORIES : DEEP_CATEGORIES;
         const results = [];
@@ -48,11 +56,13 @@ export class DreamConsolidator {
         const partial = failed > 0;
         const status = failed === results.length ? "failed" : partial ? "partial" : "completed";
         const timestamp = new Date().toISOString();
+        const operational = await this.buildOperationalReport(timestamp, results);
         const report = DreamReportSchema.parse({
             timestamp,
             tier,
             status,
             categories: results,
+            operational,
             summary: this.buildSummary(tier, results, status),
         });
         await this.persistReport(report);
@@ -69,12 +79,20 @@ export class DreamConsolidator {
             });
         }
         try {
-            const metrics = await this.collectCategoryMetrics(category, tier);
+            const pass = this.passRegistry.get(category);
+            if (!pass) {
+                throw new Error(`No Dream consolidation pass registered for ${category}`);
+            }
+            const result = await pass.run({ category, tier });
+            if (result.activationArtifacts?.length) {
+                await upsertDreamActivationArtifacts(this.deps.baseDir, result.activationArtifacts);
+                this.activationArtifactsWritten += result.activationArtifacts.length;
+            }
             return ConsolidationCategoryResultSchema.parse({
                 category,
                 status: "completed",
-                metrics,
-                warnings: [],
+                metrics: result.metrics,
+                warnings: result.warnings ?? [],
                 errors: [],
             });
         }
@@ -96,115 +114,344 @@ export class DreamConsolidator {
             ? Boolean(value.enabled)
             : true;
     }
-    async collectCategoryMetrics(category, tier) {
-        switch (category) {
-            case "memory":
-                return {
+    buildPassRegistry() {
+        const categories = [
+            ...new Set([...LIGHT_CATEGORIES, ...DEEP_CATEGORIES]),
+        ];
+        return new Map(categories.map((category) => [
+            category,
+            {
+                category,
+                run: (input) => this.collectCategoryResult(input.category, input.tier),
+            },
+        ]));
+    }
+    async collectCategoryResult(category, tier) {
+        const collectors = {
+            memory: async (tier) => ({ metrics: {
                     goalsConsidered: await this.countGoalDirs(tier),
                     latentFactsExtracted: 0,
                     lessonsDistilled: 0,
                     archivalItemsCollected: 0,
-                };
-            case "agentMemory":
-                return {
-                    lintFindings: await this.countAgentMemoryEntries(),
+                } }),
+            agentMemory: async () => ({ metrics: {
+                    agentMemoryEntriesScanned: await this.countAgentMemoryEntries(),
+                    ...(await this.collectDreamSoilSyncMetrics()),
                     autoAppliedConsolidations: 0,
                     duplicatesMerged: 0,
-                };
-            case "crossGoalTransfer":
-                return {
-                    goalPairsScanned: Math.max(0, await this.countGoalPairs()),
-                    candidatesFound: 0,
-                    transfersApplied: 0,
-                    transfersRejected: 0,
-                };
-            case "decisionHistory":
-                return {
-                    decisionRecordsScanned: await this.countFilesNamed("decision-history.json"),
-                    clustersBuilt: 0,
-                    pivotCausesPromoted: 0,
-                    staleSuggestionsFlagged: 0,
-                };
-            case "stallHistory":
-                return {
-                    stallEventsScanned: await this.countEventLines("StallDetected"),
-                    recurringLoopsDetected: 0,
-                    precursorsExtracted: 0,
-                };
-            case "sessionData":
-                return {
+                } }),
+            crossGoalTransfer: () => this.collectCrossGoalTransferResult(),
+            decisionHistory: () => this.collectDecisionHistoryResult(),
+            stallHistory: () => this.collectStallHistoryResult(),
+            sessionData: async () => ({ metrics: {
                     sessionsScanned: await this.countJsonlLines(path.join("dream", "session-logs.jsonl")),
                     coldSessionsArchived: 0,
                     bundlesCreated: 0,
                     indexEntriesUpdated: 0,
-                };
-            case "iterationLogs":
-                return {
+                } }),
+            iterationLogs: async () => ({ metrics: {
                     iterationLogsScanned: await this.countFilesNamed("iteration-logs.jsonl"),
                     rotatedLogSegments: 0,
                     archivedCompletedGoalLogs: 0,
                     indexEntriesUpdated: 0,
-                };
-            case "gapHistory":
-                return {
+                } }),
+            gapHistory: async () => ({ metrics: {
                     goalsAnalyzed: await this.countFilesNamed("gap-history.json"),
                     dimensionsModeled: 0,
                     falseProgressCasesDetected: 0,
                     archetypesEmitted: 0,
-                };
-            case "observationLogs":
-                return {
+                } }),
+            observationLogs: async () => ({ metrics: {
                     observationsScanned: await this.countFilesNamed("observations.json"),
                     flakyMethodsDetected: 0,
                     driftAlertsProduced: 0,
-                };
-            case "reports":
-                return {
+                } }),
+            reports: async () => ({ metrics: {
                     reportsScanned: await this.countJsonFiles(path.join(this.deps.baseDir, "dream", "reports")),
                     sequencesExtracted: 0,
                     summaryReportsCreated: 0,
                     lowSignalReportsCleanedUp: 0,
-                };
-            case "trustScores":
-                return {
+                } }),
+            trustScores: async () => ({ metrics: {
                     trustDomainsAnalyzed: await this.countTrustDomains(),
                     overrideEventsReplayed: 0,
                     oscillationsDetected: 0,
                     recalibrationRecommendations: 0,
-                };
-            case "strategyHistory":
-                return {
-                    timelinesReconstructed: await this.countFilesNamed("strategy-history.json"),
-                    successfulPivotLaddersFound: 0,
-                    wastefulStrategyFamiliesFlagged: 0,
-                };
-            case "verificationArtifacts":
-                return {
-                    artifactsScanned: await this.countVerificationArtifacts(),
-                    criterionFailurePatternsDetected: 0,
-                    verdictDistributionsComputed: 0,
-                };
-            case "archive":
-                return {
+                } }),
+            strategyHistory: () => this.collectStrategyHistoryResult(),
+            verificationArtifacts: () => this.collectVerificationArtifactsResult(),
+            archive: async () => ({ metrics: {
                     archivesScanned: await this.countJsonFiles(path.join(this.deps.baseDir, "archive")),
                     postmortemLessonsExtracted: 0,
                     solvedBeforeEntriesAdded: 0,
                     reusableTemplatesEmitted: 0,
-                };
-            case "knowledgeOptimization":
-                return {
-                    revalidationTasksGenerated: tier === "deep" ? 1 : 0,
-                    contradictionsFound: 0,
-                    graphEdgesInferred: 0,
-                    redundantEntriesMerged: 0,
-                };
+                } }),
+            legacyReflectionCompatibility: () => this.collectLegacyReflectionCompatibilityResult(),
+            knowledgeOptimization: (tier) => this.collectKnowledgeOptimizationResult(tier),
+        };
+        return collectors[category](tier);
+    }
+    artifactId(parts) {
+        const hash = createHash("sha256").update(parts.join("\u0000"), "utf8").digest("hex").slice(0, 16);
+        return `dream-artifact:${hash}`;
+    }
+    buildActivationArtifact(input) {
+        const now = new Date().toISOString();
+        return DreamActivationArtifactSchema.parse({
+            artifact_id: this.artifactId([input.type, input.source, JSON.stringify(input.scope ?? {})]),
+            type: input.type,
+            source: input.source,
+            scope: input.scope ?? {},
+            summary: input.summary,
+            payload: input.payload ?? {},
+            evidence_refs: input.evidenceRefs ?? [],
+            confidence: input.confidence,
+            valid_from: now,
+            valid_to: null,
+        });
+    }
+    activationArtifactIf(enabled, input) {
+        return enabled ? [this.buildActivationArtifact(input)] : [];
+    }
+    async collectStallHistoryResult() {
+        const eventMetrics = await this.collectDreamEventWorkflowMetrics();
+        const workflows = await loadDreamWorkflowRecords(this.deps.baseDir);
+        const stallWorkflows = workflows.filter((workflow) => workflow.type === "stall_recovery");
+        const activationArtifacts = this.activationArtifactIf(stallWorkflows.length > 0, {
+            type: "workflow_hint_pack",
+            source: "stallHistory",
+            summary: `${stallWorkflows.length} stall recovery workflow(s) available`,
+            payload: {
+                workflow_ids: stallWorkflows.map((workflow) => workflow.workflow_id),
+            },
+            evidenceRefs: stallWorkflows.flatMap((workflow) => workflow.evidence_refs).slice(0, 20),
+            confidence: Math.max(...stallWorkflows.map((workflow) => workflow.confidence), 0.5),
+        });
+        return {
+            metrics: {
+                ...eventMetrics,
+                stallEventsScanned: await this.countEventLines("StallDetected"),
+                recurringLoopsDetected: stallWorkflows.filter((workflow) => workflow.failure_count > 1).length,
+                precursorsExtracted: stallWorkflows.length,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
+    }
+    async collectVerificationArtifactsResult() {
+        const eventMetrics = await this.collectDreamEventWorkflowMetrics();
+        const workflows = await loadDreamWorkflowRecords(this.deps.baseDir);
+        const verificationWorkflows = workflows.filter((workflow) => workflow.type === "verification_recovery");
+        const activationArtifacts = this.activationArtifactIf(verificationWorkflows.length > 0, {
+            type: "verification_recovery_pack",
+            source: "verificationArtifacts",
+            summary: `${verificationWorkflows.length} verification recovery workflow(s) available`,
+            payload: {
+                workflow_ids: verificationWorkflows.map((workflow) => workflow.workflow_id),
+            },
+            evidenceRefs: verificationWorkflows.flatMap((workflow) => workflow.evidence_refs).slice(0, 20),
+            confidence: Math.max(...verificationWorkflows.map((workflow) => workflow.confidence), 0.5),
+        });
+        return {
+            metrics: {
+                ...eventMetrics,
+                artifactsScanned: await this.countVerificationArtifacts(),
+                criterionFailurePatternsDetected: verificationWorkflows.filter((workflow) => workflow.failure_count > 0).length,
+                verdictDistributionsComputed: verificationWorkflows.length,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
+    }
+    async collectDecisionHistoryResult() {
+        const raw = await readJsonFileOrNull(path.join(this.deps.baseDir, "dream", "decision-heuristics.json"));
+        const heuristics = typeof raw === "object" && raw !== null && Array.isArray(raw.heuristics)
+            ? raw.heuristics
+            : [];
+        const activationArtifacts = this.activationArtifactIf(heuristics.length > 0, {
+            type: "decision_heuristic_pack",
+            source: "decisionHistory",
+            summary: `${heuristics.length} decision heuristic(s) available`,
+            payload: { heuristic_count: heuristics.length },
+            confidence: 0.65,
+        });
+        return {
+            metrics: {
+                decisionRecordsScanned: await this.countFilesNamed("decision-history.json"),
+                heuristicsAvailable: heuristics.length,
+                clustersBuilt: heuristics.length > 0 ? 1 : 0,
+                pivotCausesPromoted: 0,
+                staleSuggestionsFlagged: 0,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
+    }
+    async collectStrategyHistoryResult() {
+        const raw = await readJsonFileOrNull(path.join(this.deps.baseDir, "strategy-templates.json"));
+        const templates = Array.isArray(raw) ? raw : [];
+        const activationArtifacts = this.activationArtifactIf(templates.length > 0, {
+            type: "pattern_hint_pack",
+            source: "strategyHistory",
+            summary: `${templates.length} strategy template(s) available`,
+            payload: { template_count: templates.length },
+            confidence: 0.65,
+        });
+        return {
+            metrics: {
+                timelinesReconstructed: await this.countFilesNamed("strategy-history.json"),
+                strategyTemplatesAvailable: templates.length,
+                successfulPivotLaddersFound: templates.length,
+                wastefulStrategyFamiliesFlagged: 0,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
+    }
+    async collectCrossGoalTransferResult() {
+        const learnedPatterns = await this.countLearnedPatterns();
+        const activationArtifacts = this.activationArtifactIf(learnedPatterns > 0, {
+            type: "semantic_context_pack",
+            source: "crossGoalTransfer",
+            summary: `${learnedPatterns} learned pattern(s) available for cross-goal transfer`,
+            payload: { learned_pattern_count: learnedPatterns },
+            confidence: 0.6,
+        });
+        return {
+            metrics: {
+                goalPairsScanned: Math.max(0, await this.countGoalPairs()),
+                candidatesFound: learnedPatterns,
+                transfersApplied: 0,
+                transfersRejected: 0,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
+    }
+    async collectLegacyReflectionCompatibilityResult() {
+        if (!this.deps.legacyConsolidationService) {
+            return {
+                metrics: {
+                    legacyGoalsConsolidated: 0,
+                    legacyEntriesCompressed: 0,
+                    legacyStaleEntriesFound: 0,
+                    legacyRevalidationTasksCreated: 0,
+                },
+                warnings: ["legacy compatibility service unavailable"],
+            };
+        }
+        const report = await this.deps.legacyConsolidationService.run({ baseDir: this.deps.baseDir });
+        return {
+            metrics: {
+                legacyGoalsConsolidated: report.goals_consolidated,
+                legacyEntriesCompressed: report.entries_compressed,
+                legacyStaleEntriesFound: report.stale_entries_found,
+                legacyRevalidationTasksCreated: report.revalidation_tasks_created,
+            },
+        };
+    }
+    async collectKnowledgeOptimizationResult(tier) {
+        const config = this.config.knowledgeOptimization;
+        const baseMetrics = {
+            revalidationTasksGenerated: 0,
+            contradictionsFound: 0,
+            stalenessFound: 0,
+            redundantEntriesFound: 0,
+            graphEdgesInferred: 0,
+            redundantEntriesMerged: 0,
+            memoryQualityFindings: 0,
+            memoryQualityRepairsApplied: 0,
+            memoryQualityEntriesFlagged: 0,
+            activationArtifactsEmitted: 0,
+        };
+        if (!this.deps.memoryQualityService) {
+            return {
+                metrics: baseMetrics,
+                warnings: ["memory quality service unavailable"],
+            };
         }
+        const quality = await this.deps.memoryQualityService.run({
+            baseDir: this.deps.baseDir,
+            autoRepair: config.autoRepairAgentMemory,
+            minAutoRepairConfidence: config.minAutoRepairConfidence,
+        });
+        const activationArtifacts = this.activationArtifactIf(quality.findings > 0, {
+            type: "knowledge_gap_pack",
+            source: "knowledgeOptimization",
+            summary: `${quality.findings} memory quality issue(s) found`,
+            payload: {
+                contradictions_found: quality.contradictionsFound,
+                staleness_found: quality.stalenessFound,
+                redundancy_found: quality.redundancyFound,
+                repairs_applied: quality.repairsApplied,
+                entries_flagged: quality.entriesFlagged,
+            },
+            confidence: quality.repairsApplied > 0 ? 0.85 : 0.7,
+        });
+        return {
+            metrics: {
+                ...baseMetrics,
+                revalidationTasksGenerated: quality.stalenessFound,
+                contradictionsFound: quality.contradictionsFound,
+                stalenessFound: quality.stalenessFound,
+                redundantEntriesFound: quality.redundancyFound,
+                redundantEntriesMerged: quality.redundancyFound,
+                memoryQualityFindings: quality.findings,
+                memoryQualityRepairsApplied: quality.repairsApplied,
+                memoryQualityEntriesFlagged: quality.entriesFlagged,
+                activationArtifactsEmitted: activationArtifacts.length,
+            },
+            activationArtifacts,
+        };
     }
     buildSummary(tier, results, status) {
         const completed = results.filter((result) => result.status === "completed").length;
         const failed = results.filter((result) => result.status === "failed").length;
         return `Dream consolidation (${tier}) ${status}: ${completed} categories completed, ${failed} failed.`;
     }
+    async buildOperationalReport(timestamp, results) {
+        const backlog = await this.collectBacklogMetrics();
+        const workflows = await loadDreamWorkflowRecords(this.deps.baseDir);
+        const activationArtifacts = await loadDreamActivationArtifacts(this.deps.baseDir);
+        const failures = results.flatMap((result) => result.errors.map((error) => ({
+            category: result.category,
+            source_ref: null,
+            reason: error,
+        })));
+        const metricSum = (key) => results.reduce((sum, result) => sum + (result.metrics[key] ?? 0), 0);
+        const legacy = results.find((result) => result.category === "legacyReflectionCompatibility")?.metrics ?? {};
+        return DreamOperationalReportSchema.parse({
+            run_id: `dream-${timestamp.replaceAll(":", "-")}`,
+            watermarks: {
+                advanced: metricSum("eventWorkflowWatermarksAdvanced"),
+                unchanged: backlog.iteration_lines_pending + backlog.event_lines_pending + backlog.importance_entries_pending === 0 ? 1 : 0,
+                lagging_sources: [
+                    ...(backlog.iteration_lines_pending > 0 ? ["iteration"] : []),
+                    ...(backlog.event_lines_pending > 0 ? ["event"] : []),
+                    ...(backlog.importance_entries_pending > 0 ? ["importance"] : []),
+                ],
+            },
+            consolidation: {
+                records_created: metricSum("soilSyncRecordsWritten"),
+                records_updated: metricSum("soilSyncChangedSearchMaterial"),
+                records_superseded: metricSum("soilSyncRecordsSuperseded"),
+                tombstones_written: metricSum("soilSyncTombstonesWritten"),
+                artifacts_created: this.activationArtifactsWritten,
+            },
+            backlog,
+            artifact_growth: {
+                workflows: workflows.length,
+                activation_artifacts: activationArtifacts.length,
+            },
+            failures,
+            legacy_reflection: {
+                goals_consolidated: legacy["legacyGoalsConsolidated"] ?? 0,
+                entries_compressed: legacy["legacyEntriesCompressed"] ?? 0,
+                stale_entries_found: legacy["legacyStaleEntriesFound"] ?? 0,
+                revalidation_tasks_created: legacy["legacyRevalidationTasksCreated"] ?? 0,
+            },
+        });
+    }
     async persistReport(report) {
         const reportsDir = path.join(this.deps.baseDir, "dream", "reports");
         await fsp.mkdir(reportsDir, { recursive: true });
@@ -220,6 +467,52 @@ export class DreamConsolidator {
         const count = await this.countGoalDirs("deep");
         return count < 2 ? 0 : (count * (count - 1)) / 2;
     }
+    async countLearnedPatterns() {
+        const learningDir = path.join(this.deps.baseDir, "learning");
+        const files = await fsp.readdir(learningDir).catch(() => []);
+        let total = 0;
+        for (const fileName of files.filter((file) => file.endsWith("_patterns.json"))) {
+            const raw = await readJsonFileOrNull(path.join(learningDir, fileName));
+            if (Array.isArray(raw)) {
+                total += raw.length;
+            }
+        }
+        return total;
+    }
+    async collectBacklogMetrics() {
+        const raw = await readJsonFileOrNull(path.join(this.deps.baseDir, "dream", "watermarks.json"));
+        const watermarks = raw === null ? WatermarkStateSchema.parse({}) : WatermarkStateSchema.safeParse(raw).success
+            ? WatermarkStateSchema.parse(raw)
+            : WatermarkStateSchema.parse({});
+        let iterationLinesPending = 0;
+        const goalsDir = path.join(this.deps.baseDir, "goals");
+        const goalEntries = await fsp.readdir(goalsDir, { withFileTypes: true }).catch(() => []);
+        for (const entry of goalEntries.filter((candidate) => candidate.isDirectory())) {
+            const total = await this.countFileLines(path.join(goalsDir, entry.name, "iteration-logs.jsonl"));
+            const lastProcessed = watermarks.goals[entry.name]?.lastProcessedLine ?? 0;
+            iterationLinesPending += Math.max(0, total - Math.min(lastProcessed, total));
+        }
+        let eventLinesPending = 0;
+        const eventDir = path.join(this.deps.baseDir, "dream", "events");
+        const eventFiles = await fsp.readdir(eventDir).catch(() => []);
+        for (const fileName of eventFiles.filter((file) => file.endsWith(".jsonl"))) {
+            const total = await this.countFileLines(path.join(eventDir, fileName));
+            const lastProcessed = watermarks.goals[`event:${fileName}`]?.lastProcessedLine ?? 0;
+            eventLinesPending += Math.max(0, total - Math.min(lastProcessed, total));
+        }
+        const importanceLines = await this.countFileLines(path.join(this.deps.baseDir, "dream", "importance-buffer.jsonl"));
+        const importanceProcessed = watermarks.importanceBuffer.lastProcessedLine ?? 0;
+        const importanceEntriesPending = Math.max(0, importanceLines - Math.min(importanceProcessed, importanceLines));
+        return {
+            iteration_lines_pending: iterationLinesPending,
+            event_lines_pending: eventLinesPending,
+            importance_entries_pending: importanceEntriesPending,
+        };
+    }
+    async countFileLines(filePath) {
+        const raw = await fsp.readFile(filePath, "utf8").catch(() => "");
+        return raw.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+    }
     async countFilesNamed(fileName) {
         let count = 0;
         for await (const filePath of this.walk(this.deps.baseDir)) {
@@ -259,6 +552,64 @@ export class DreamConsolidator {
         const parsed = JSON.parse(raw);
         return Array.isArray(parsed.entries) ? parsed.entries.length : 0;
     }
+    async collectDreamSoilSyncMetrics() {
+        await this.collectDreamEventWorkflowMetrics();
+        if (!this.deps.syncService) {
+            return {
+                soilSyncRecordsWritten: 0,
+                soilSyncChunksWritten: 0,
+                soilSyncTombstonesWritten: 0,
+            };
+        }
+        let report;
+        try {
+            report = await this.deps.syncService.syncFromCurrentDreamState({ baseDir: this.deps.baseDir });
+        }
+        catch (error) {
+            this.logger?.warn("Dream Soil sync failed", { error: error instanceof Error ? error.message : String(error) });
+            return {
+                soilSyncFailures: 1,
+                soilSyncRecordsWritten: 0,
+                soilSyncChunksWritten: 0,
+                soilSyncTombstonesWritten: 0,
+            };
+        }
+        return {
+            soilSyncAgentMemoryEntries: report.agentMemoryEntries,
+            soilSyncLearnedPatterns: report.learnedPatterns,
+            soilSyncWorkflowRecords: report.workflowRecords,
+            soilSyncPreviousRecords: report.previousRecords,
+            soilSyncRecordsWritten: report.recordsWritten,
+            soilSyncRecordsSuperseded: report.recordsSuperseded,
+            soilSyncChunksWritten: report.chunksWritten,
+            soilSyncTombstonesWritten: report.tombstonesWritten,
+            soilSyncChangedSearchMaterial: report.recordsWithChangedSearchMaterial,
+            soilSyncQueueReindexRecordIds: report.queueReindexRecordIds,
+        };
+    }
+    eventWorkflowMetricsPromise = null;
+    async collectDreamEventWorkflowMetrics() {
+        this.eventWorkflowMetricsPromise ??= consolidateDreamEventWorkflows(this.deps.baseDir)
+            .then((report) => ({
+            eventWorkflowEventsScanned: report.eventsScanned,
+            eventWorkflowMalformedEvents: report.malformedEvents,
+            eventWorkflowCandidates: report.workflowCandidates,
+            eventWorkflowRecordsWritten: report.workflowsWritten,
+            eventWorkflowWatermarksAdvanced: report.eventWatermarksAdvanced,
+        }))
+            .catch((error) => {
+            this.logger?.warn("Dream event workflow consolidation failed", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return {
+                eventWorkflowFailures: 1,
+                eventWorkflowEventsScanned: 0,
+                eventWorkflowCandidates: 0,
+                eventWorkflowRecordsWritten: 0,
+            };
+        });
+        return this.eventWorkflowMetricsPromise;
+    }
     async countEventLines(eventType) {
         const dreamDir = path.join(this.deps.baseDir, "dream", "events");
         let total = 0;