agentic-qe 3.3.1 → 3.3.3

package/v3/dist/domains/learning-optimization/coordinator.js

@@ -8,12 +8,36 @@ import { TimeRange } from '../../shared/value-objects/index.js';
 import { LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events.js';
 import { LearningCoordinatorService, TransferSpecialistService, MetricsOptimizerService, ProductionIntelService, } from './services/index.js';
 import { createPersistentSONAEngine, } from '../../integrations/ruvector/sona-persistence.js';
+import { createDreamScheduler, createDreamEngine, } from '../../learning/dream/index.js';
+// ============================================================================
+// MinCut & Consensus Mixin Imports (ADR-047, MM-001)
+// ============================================================================
+import { createMinCutAwareMixin, } from '../../coordination/mixins/mincut-aware-domain.js';
+import { createConsensusEnabledMixin, } from '../../coordination/mixins/consensus-enabled-domain.js';
+import { createDomainFinding, } from '../../coordination/consensus/domain-findings.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 3,
     defaultTimeout: 120000, // 2 minutes
     enableAutoOptimization: true,
     publishEvents: true,
     learningCycleIntervalMs: 3600000, // 1 hour
+    // Dream Scheduler defaults
+    enableDreamScheduler: true,
+    dreamCycleIntervalMs: 3600000, // 1 hour
+    enableExperienceTrigger: true,
+    experienceThreshold: 50,
+    enableQualityGateFailureTrigger: true,
+    autoApplyHighConfidenceInsights: false,
+    autoApplyConfidenceThreshold: 0.8,
+    // MinCut integration defaults (ADR-047)
+    enableMinCutAwareness: true,
+    topologyHealthThreshold: 0.5,
+    pauseOnCriticalTopology: false,
+    // Consensus integration defaults (MM-001)
+    enableConsensus: true,
+    consensusThreshold: 0.7,
+    consensusStrategy: 'weighted',
+    consensusMinModels: 2,
 };
 /**
  * Learning & Optimization Coordinator
@@ -36,12 +60,40 @@ export class LearningOptimizationCoordinator {
      * Now uses PersistentSONAEngine to survive restarts
      */
     sona;
+    /**
+     * DreamScheduler for offline pattern consolidation and insight generation
+     * Wraps DreamEngine with automatic scheduling and trigger support
+     */
+    dreamScheduler = null;
+    // MinCut topology awareness mixin (ADR-047)
+    minCutMixin;
+    // Consensus verification mixin (MM-001)
+    consensusMixin;
+    // Domain identifier for mixin initialization
+    domainName = 'learning-optimization';
     constructor(eventBus, memory, agentCoordinator, config = {}) {
         this.eventBus = eventBus;
         this.memory = memory;
         this.agentCoordinator = agentCoordinator;
         this.config = { ...DEFAULT_CONFIG, ...config };
-        this.learningService = new LearningCoordinatorService(memory);
+        // Initialize MinCut-aware mixin (ADR-047)
+        this.minCutMixin = createMinCutAwareMixin(this.domainName, {
+            enableMinCutAwareness: this.config.enableMinCutAwareness,
+            topologyHealthThreshold: this.config.topologyHealthThreshold,
+            pauseOnCriticalTopology: this.config.pauseOnCriticalTopology,
+        });
+        // Initialize Consensus-enabled mixin (MM-001)
+        this.consensusMixin = createConsensusEnabledMixin({
+            enableConsensus: this.config.enableConsensus,
+            consensusThreshold: this.config.consensusThreshold,
+            verifyFindingTypes: ['pattern-recommendation', 'optimization-suggestion', 'cross-domain-insight'],
+            strategy: this.config.consensusStrategy,
+            minModels: this.config.consensusMinModels,
+            modelTimeout: 60000,
+            verifySeverities: ['critical', 'high'],
+            enableLogging: false,
+        });
+        this.learningService = new LearningCoordinatorService({ memory });
         this.transferService = new TransferSpecialistService(memory);
         this.optimizerService = new MetricsOptimizerService(memory);
         this.productionIntel = new ProductionIntelService(memory);
@@ -68,20 +120,77 @@ export class LearningOptimizationCoordinator {
             console.error('[LearningOptimizationCoordinator] Failed to initialize PersistentSONAEngine:', error);
             throw error; // Learning optimization requires SONA
         }
+        // Initialize DreamScheduler if enabled
+        if (this.config.enableDreamScheduler) {
+            try {
+                const dreamEngine = await createDreamEngine();
+                await dreamEngine.initialize();
+                this.dreamScheduler = createDreamScheduler({
+                    dreamEngine,
+                    eventBus: this.eventBus,
+                    memoryBackend: this.memory,
+                }, {
+                    autoScheduleIntervalMs: this.config.dreamCycleIntervalMs,
+                    enableExperienceTrigger: this.config.enableExperienceTrigger,
+                    experienceThreshold: this.config.experienceThreshold,
+                    enableQualityGateFailureTrigger: this.config.enableQualityGateFailureTrigger,
+                    autoApplyHighConfidenceInsights: this.config.autoApplyHighConfidenceInsights,
+                    insightConfidenceThreshold: this.config.autoApplyConfidenceThreshold,
+                });
+                await this.dreamScheduler.initialize();
+                this.dreamScheduler.start();
+                console.log('[LearningOptimizationCoordinator] DreamScheduler initialized and started');
+            }
+            catch (error) {
+                console.warn('[LearningOptimizationCoordinator] Failed to initialize DreamScheduler:', error);
+                // DreamScheduler is optional - continue without it
+            }
+        }
         // Subscribe to relevant events
         this.subscribeToEvents();
         // Load any persisted workflow state
         await this.loadWorkflowState();
+        // Initialize Consensus engine if enabled (MM-001)
+        if (this.config.enableConsensus) {
+            try {
+                await this.consensusMixin.initializeConsensus();
+                console.log(`[${this.domainName}] Consensus engine initialized`);
+            }
+            catch (error) {
+                console.error(`[${this.domainName}] Failed to initialize consensus engine:`, error);
+                console.warn(`[${this.domainName}] Continuing without consensus verification`);
+            }
+        }
         this.initialized = true;
     }
     /**
      * Dispose and cleanup
      */
     async dispose() {
+        // Dispose Consensus engine (MM-001)
+        try {
+            await this.consensusMixin.disposeConsensus();
+        }
+        catch (error) {
+            console.error(`[${this.domainName}] Error disposing consensus engine:`, error);
+        }
+        // Dispose MinCut mixin (ADR-047)
+        this.minCutMixin.dispose();
         // Save workflow state
         await this.saveWorkflowState();
         // Clear active workflows
         this.workflows.clear();
+        // Dispose DreamScheduler
+        if (this.dreamScheduler) {
+            try {
+                await this.dreamScheduler.dispose();
+                console.log('[LearningOptimizationCoordinator] DreamScheduler disposed');
+            }
+            catch (error) {
+                console.error('[LearningOptimizationCoordinator] Error disposing DreamScheduler:', error);
+            }
+            this.dreamScheduler = null;
+        }
         // V3: Clean up SONA engine (persistent patterns)
         if (this.initialized && this.sona) {
             try {
@@ -109,6 +218,15 @@ export class LearningOptimizationCoordinator {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'learning-cycle');
+            // ADR-047: Check topology health before expensive operations
+            if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
+                console.warn(`[${this.domainName}] Topology degraded, using conservative strategy for learning cycle`);
+                // Continue with reduced scope when topology is unhealthy
+            }
+            // ADR-047: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                return err(new Error('Learning cycle paused: topology is in critical state'));
+            }
             // Spawn learning agent
             const agentResult = await this.spawnLearningAgent(workflowId, domain);
             if (!agentResult.success) {
@@ -191,6 +309,14 @@ export class LearningOptimizationCoordinator {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'optimization');
+            // ADR-047: Check topology health before expensive operations
+            if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
+                console.warn(`[${this.domainName}] Topology degraded, using conservative optimization strategy`);
+            }
+            // ADR-047: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                return err(new Error('Optimization paused: topology is in critical state'));
+            }
             const byDomain = {};
             let totalStrategies = 0;
             let totalImprovement = 0;
@@ -250,6 +376,14 @@ export class LearningOptimizationCoordinator {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'transfer');
+            // ADR-047: Check topology health before cross-domain operations
+            if (this.config.enableMinCutAwareness && !this.isTopologyHealthy()) {
+                console.warn(`[${this.domainName}] Topology degraded, limiting cross-domain transfer scope`);
+            }
+            // ADR-047: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                return err(new Error('Cross-domain sharing paused: topology is in critical state'));
+            }
             let knowledgeShared = 0;
             const domainsUpdated = [];
             let newPatternsCreated = 0;
@@ -528,6 +662,85 @@ export class LearningOptimizationCoordinator {
         this.ensureInitialized();
         return this.sona.verifyPerformance(iterations);
     }
+    // ============================================================================
+    // Dream Scheduler Methods
+    // ============================================================================
+    /**
+     * Trigger a dream cycle manually.
+     * Dreams consolidate patterns and generate novel insights through spreading activation.
+     *
+     * @param durationMs - Optional duration override in ms
+     * @returns Dream cycle result with generated insights
+     * @throws Error if DreamScheduler is not initialized
+     */
+    async triggerDreamCycle(durationMs) {
+        if (!this.dreamScheduler) {
+            throw new Error('[LearningOptimizationCoordinator] DreamScheduler not initialized');
+        }
+        const result = await this.dreamScheduler.triggerDream(durationMs);
+        // Publish event for other domains to consume
+        if (this.config.publishEvents) {
+            await this.publishDreamCycleCompleted(result.cycle.id, result.cycle.durationMs ?? 0, result.cycle.conceptsProcessed, result.insights.map((i) => ({
+                id: i.id,
+                type: i.type,
+                description: i.description,
+                noveltyScore: i.noveltyScore,
+                confidenceScore: i.confidenceScore,
+                actionable: i.actionable,
+                suggestedAction: i.suggestedAction,
+                sourceConcepts: i.sourceConcepts,
+            })), result.patternsCreated);
+        }
+        return result;
+    }
+    /**
+     * Get the current status of the DreamScheduler.
+     *
+     * @returns DreamScheduler status or null if not initialized
+     */
+    getDreamStatus() {
+        return this.dreamScheduler?.getStatus() ?? null;
+    }
+    /**
+     * Check if the DreamScheduler is available and running.
+     *
+     * @returns True if DreamScheduler is initialized
+     */
+    isDreamSchedulerAvailable() {
+        return this.dreamScheduler !== null;
+    }
+    /**
+     * Get the last dream cycle result from the scheduler.
+     *
+     * @returns Last dream result or null if no dreams have completed
+     */
+    getLastDreamResult() {
+        return this.dreamScheduler?.getLastDreamResult() ?? null;
+    }
+    /**
+     * Trigger a quick dream cycle for rapid insight generation.
+     *
+     * @returns Dream cycle result
+     * @throws Error if DreamScheduler is not initialized
+     */
+    async triggerQuickDream() {
+        if (!this.dreamScheduler) {
+            throw new Error('[LearningOptimizationCoordinator] DreamScheduler not initialized');
+        }
+        return this.dreamScheduler.triggerQuickDream();
+    }
+    /**
+     * Trigger a full dream cycle for comprehensive pattern consolidation.
+     *
+     * @returns Dream cycle result
+     * @throws Error if DreamScheduler is not initialized
+     */
+    async triggerFullDream() {
+        if (!this.dreamScheduler) {
+            throw new Error('[LearningOptimizationCoordinator] DreamScheduler not initialized');
+        }
+        return this.dreamScheduler.triggerFullDream();
+    }
     /**
      * Export learned models
      */
@@ -879,6 +1092,23 @@ export class LearningOptimizationCoordinator {
             }
             console.log(`[LearningOptimizationCoordinator] Experience ${experience.id} transferred to ${relatedDomains.length} related domains`);
         }
+        // Record experience for dream scheduler to trigger insight generation
+        if (this.dreamScheduler) {
+            this.dreamScheduler.recordExperience({
+                id: experience.id,
+                agentType: experience.agent || 'unknown',
+                domain: domain,
+                taskType: experience.task,
+                success: experience.success,
+                duration: experience.durationMs,
+                context: {
+                    quality: experience.quality,
+                    steps: experience.steps.length,
+                    patterns: experience.patterns?.length || 0,
+                },
+                timestamp: new Date(experience.startedAt),
+            });
+        }
     }
     // ============================================================================
     // Event Publishing
@@ -909,6 +1139,33 @@ export class LearningOptimizationCoordinator {
         });
         await this.eventBus.publish(event);
     }
+    /**
+     * Publish a dream cycle completion event.
+     * This broadcasts dream insights to all interested domain coordinators.
+     *
+     * Called by the DreamScheduler or DreamEngine after completing a dream cycle.
+     *
+     * @param cycleId - Unique identifier for the dream cycle
+     * @param durationMs - How long the dream cycle took
+     * @param conceptsProcessed - Number of concepts processed during dreaming
+     * @param insights - Array of insights generated during the dream cycle
+     * @param patternsCreated - Number of patterns created from insights
+     */
+    async publishDreamCycleCompleted(cycleId, durationMs, conceptsProcessed, insights, patternsCreated) {
+        if (!this.config.publishEvents) {
+            return;
+        }
+        const payload = {
+            cycleId,
+            durationMs,
+            conceptsProcessed,
+            insights,
+            patternsCreated,
+        };
+        const event = createEvent(LearningOptimizationEvents.DreamCycleCompleted, 'learning-optimization', payload);
+        await this.eventBus.publish(event);
+        console.log(`[LearningOptimizationCoordinator] Published dream cycle completion: ${insights.length} insights for ${conceptsProcessed} concepts`);
+    }
     // ============================================================================
     // Agent Management
     // ============================================================================
@@ -1106,5 +1363,148 @@ export class LearningOptimizationCoordinator {
         }
         return Math.abs(hash).toString(16);
     }
+    // ============================================================================
+    // MinCut Integration Methods (ADR-047)
+    // ============================================================================
+    /**
+     * Set the MinCut bridge for topology awareness
+     */
+    setMinCutBridge(bridge) {
+        this.minCutMixin.setMinCutBridge(bridge);
+        console.log(`[${this.domainName}] MinCut bridge connected for topology awareness`);
+    }
+    /**
+     * Check if topology is healthy
+     */
+    isTopologyHealthy() {
+        return this.minCutMixin.isTopologyHealthy();
+    }
+    /**
+     * Get topology-based routing excluding weak domains
+     * Per ADR-047: Filters out domains that are currently weak points
+     *
+     * @param targetDomains - List of potential target domains
+     * @returns Filtered list of healthy domains for routing
+     */
+    getTopologyBasedRouting(targetDomains) {
+        return this.minCutMixin.getTopologyBasedRouting(targetDomains);
+    }
+    /**
+     * Get weak vertices belonging to this domain
+     * Per ADR-047: Identifies agents that are single points of failure
+     */
+    getDomainWeakVertices() {
+        return this.minCutMixin.getDomainWeakVertices();
+    }
+    /**
+     * Check if this domain is a weak point in the topology
+     * Per ADR-047: Returns true if any weak vertex belongs to learning-optimization domain
+     */
+    isDomainWeakPoint() {
+        return this.minCutMixin.isDomainWeakPoint();
+    }
+    // ============================================================================
+    // Consensus Integration Methods (MM-001)
+    // ============================================================================
+    /**
+     * Check if consensus engine is available
+     */
+    isConsensusAvailable() {
+        return this.consensusMixin.isConsensusAvailable?.() ?? false;
+    }
+    /**
+     * Get consensus statistics
+     * Per MM-001: Returns metrics about consensus verification
+     */
+    getConsensusStats() {
+        return this.consensusMixin.getConsensusStats();
+    }
+    /**
+     * Verify a pattern recommendation using multi-model consensus
+     * Per MM-001: High-stakes pattern recommendations require verification
+     *
+     * @param pattern - The pattern being recommended
+     * @param confidence - Initial confidence in the recommendation
+     * @returns true if the recommendation is verified or doesn't require consensus
+     */
+    async verifyPatternRecommendation(pattern, confidence) {
+        const finding = createDomainFinding({
+            id: uuidv4(),
+            type: 'pattern-recommendation',
+            confidence,
+            description: `Verify pattern recommendation: ${pattern.name} (${pattern.type}) for domain ${pattern.domain}`,
+            payload: pattern,
+            detectedBy: 'learning-optimization-coordinator',
+            severity: confidence > 0.9 ? 'high' : 'medium',
+        });
+        if (this.consensusMixin.requiresConsensus(finding)) {
+            const result = await this.consensusMixin.verifyFinding(finding);
+            if (result.success && result.value.verdict === 'verified') {
+                console.log(`[${this.domainName}] Pattern recommendation '${pattern.name}' verified by consensus`);
+                return true;
+            }
+            console.warn(`[${this.domainName}] Pattern recommendation '${pattern.name}' NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            return false;
+        }
+        return true; // No consensus needed
+    }
+    /**
+     * Verify an optimization suggestion using multi-model consensus
+     * Per MM-001: Optimization suggestions can have significant impact
+     *
+     * @param suggestion - The optimization suggestion to verify
+     * @param confidence - Initial confidence in the suggestion
+     * @returns true if the suggestion is verified or doesn't require consensus
+     */
+    async verifyOptimizationSuggestion(suggestion, confidence) {
+        const finding = createDomainFinding({
+            id: uuidv4(),
+            type: 'optimization-suggestion',
+            confidence,
+            description: `Verify optimization: ${suggestion.metric} from ${suggestion.currentValue} to ${suggestion.targetValue} via ${suggestion.strategy}`,
+            payload: suggestion,
+            detectedBy: 'learning-optimization-coordinator',
+            severity: confidence > 0.85 ? 'high' : 'medium',
+        });
+        if (this.consensusMixin.requiresConsensus(finding)) {
+            const result = await this.consensusMixin.verifyFinding(finding);
+            if (result.success && result.value.verdict === 'verified') {
+                console.log(`[${this.domainName}] Optimization suggestion for '${suggestion.metric}' verified by consensus`);
+                return true;
+            }
+            console.warn(`[${this.domainName}] Optimization suggestion for '${suggestion.metric}' NOT verified`);
+            return false;
+        }
+        return true; // No consensus needed
+    }
+    /**
+     * Verify a cross-domain insight using multi-model consensus
+     * Per MM-001: Cross-domain insights require verification before propagation
+     *
+     * @param insight - The cross-domain insight to verify
+     * @param confidence - Initial confidence in the insight
+     * @returns true if the insight is verified or doesn't require consensus
+     */
+    async verifyCrossDomainInsight(insight, confidence) {
+        const finding = createDomainFinding({
+            id: uuidv4(),
+            type: 'cross-domain-insight',
+            confidence,
+            description: `Verify cross-domain insight: ${insight.description}`,
+            payload: insight,
+            detectedBy: 'learning-optimization-coordinator',
+            severity: 'high', // Cross-domain insights always have high impact
+        });
+        if (this.consensusMixin.requiresConsensus(finding)) {
+            const result = await this.consensusMixin.verifyFinding(finding);
+            if (result.success && result.value.verdict === 'verified') {
+                console.log(`[${this.domainName}] Cross-domain insight verified by consensus for ${insight.targetDomains.length} target domains`);
+                return true;
+            }
+            console.warn(`[${this.domainName}] Cross-domain insight NOT verified: ${result.success ? result.value.verdict : result.error.message}`);
+            return false;
+        }
+        return true; // No consensus needed
+    }
 }
 //# sourceMappingURL=coordinator.js.map