agentic-qe 3.3.1 → 3.3.3

package/v3/dist/domains/quality-assessment/coordinator.js

@@ -6,10 +6,14 @@
  * - ActorCritic RL: Quality gate threshold tuning
  * - QESONA: Quality pattern learning
  * - QEFlashAttention: Similarity computations for quality reports
+ *
+ * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
+ * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
+ * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
  */
 import { v4 as uuidv4 } from 'uuid';
 import { ok, err } from '../../shared/types';
-import { QualityAssessmentEvents, createEvent, } from '../../shared/events/domain-events';
+import { QualityAssessmentEvents, LearningOptimizationEvents, createEvent, } from '../../shared/events/domain-events';
 import { QualityGateService, } from './services/quality-gate';
 import { QualityAnalyzerService, } from './services/quality-analyzer';
 import { DeploymentAdvisorService, } from './services/deployment-advisor';
@@ -19,6 +23,11 @@ import { createPersistentSONAEngine } from '../../integrations/ruvector/sona-per
 import { createQEFlashAttention, } from '../../integrations/ruvector/wrappers';
 // V3 Integration: ClaimVerifier for report verification (Phase 4)
 import { createClaimVerifierService, } from '../../agents/claim-verifier/index.js';
+// V3 Integration: MinCut Awareness (ADR-047)
+import { createMinCutAwareMixin, } from '../../coordination/mixins/mincut-aware-domain';
+// V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+import { createConsensusEnabledMixin, } from '../../coordination/mixins/consensus-enabled-domain';
+import { createDomainFinding, } from '../../coordination/consensus/domain-findings';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 5,
     defaultTimeout: 60000,
@@ -29,6 +38,14 @@ const DEFAULT_CONFIG = {
     enableFlashAttention: true,
     // V3: ClaimVerifier enabled by default
     enableClaimVerification: true,
+    // V3: MinCut Awareness enabled by default
+    enableMinCutAwareness: true,
+    topologyHealthThreshold: 0.5,
+    // V3: Consensus enabled by default for quality decisions
+    enableConsensus: true,
+    consensusThreshold: 0.7,
+    consensusMinModels: 2,
+    borderlineMargin: 0.05, // 5% margin for borderline detection
 };
 /**
  * Quality Assessment Coordinator
@@ -38,6 +55,10 @@ const DEFAULT_CONFIG = {
  * - ActorCritic RL: Quality gate threshold tuning
  * - QESONA: Quality pattern learning
  * - QEFlashAttention: Similarity computations for quality reports
+ *
+ * V3 Integrations (ADR-047, CONSENSUS-MIXIN-001):
+ * - MinCutAwareDomainMixin: Topology-aware routing and health monitoring
+ * - ConsensusEnabledMixin: Multi-model consensus for high-stakes quality decisions
  */
 export class QualityAssessmentCoordinator {
     eventBus;
@@ -55,8 +76,14 @@ export class QualityAssessmentCoordinator {
     flashAttention;
     // V3 Integration: ClaimVerifier for report verification
     claimVerifier;
+    // V3 Integration: MinCut Awareness (ADR-047)
+    minCutMixin;
+    // V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+    consensusMixin;
     // Quality domain name for SONA
     domain = 'quality-assessment';
+    // Cache of recent dream insights for quality assessment enhancement
+    recentDreamInsights = [];
     constructor(eventBus, memory, agentCoordinator, config = {}) {
         this.eventBus = eventBus;
         this.memory = memory;
@@ -65,10 +92,36 @@ export class QualityAssessmentCoordinator {
         this.qualityGate = new QualityGateService(memory);
         this.qualityAnalyzer = new QualityAnalyzerService(memory);
         this.deploymentAdvisor = new DeploymentAdvisorService(memory);
+        // V3 Integration: Initialize MinCut Awareness Mixin (ADR-047)
+        this.minCutMixin = createMinCutAwareMixin(this.domain, {
+            enableMinCutAwareness: this.config.enableMinCutAwareness,
+            topologyHealthThreshold: this.config.topologyHealthThreshold,
+            pauseOnCriticalTopology: false, // Quality assessment continues even in degraded topology
+            monitoredDomains: [], // Monitor all domains
+        });
+        // V3 Integration: Initialize Consensus Mixin (CONSENSUS-MIXIN-001)
+        // Configured for quality-assessment specific finding types
+        this.consensusMixin = createConsensusEnabledMixin({
+            enableConsensus: this.config.enableConsensus,
+            consensusThreshold: this.config.consensusThreshold,
+            minModels: this.config.consensusMinModels,
+            // Quality-specific finding types that require consensus
+            verifyFindingTypes: [
+                'gate-verdict', // Pass/fail quality gate decisions
+                'tech-debt-classification', // Critical vs acceptable tech debt
+                'release-readiness', // Go/no-go deployment decisions
+                'risk-scoring', // High-risk deployment detection
+            ],
+            strategy: 'weighted',
+            modelTimeout: 60000,
+            verifySeverities: ['critical', 'high'],
+            enableLogging: false,
+        });
     }
     /**
      * Initialize the coordinator
      * Sets up Ruvector integrations: ActorCritic, QESONA, QEFlashAttention
+     * V3: Also initializes MinCut awareness and Consensus verification
      */
     async initialize() {
         if (this.initialized)
@@ -94,6 +147,10 @@ export class QualityAssessmentCoordinator {
             if (this.config.enableClaimVerification) {
                 await this.initializeClaimVerifier();
             }
+            // V3 Integration: Initialize Consensus Engine (CONSENSUS-MIXIN-001)
+            if (this.config.enableConsensus) {
+                await this.initializeConsensus();
+            }
             this.initialized = true;
         }
         catch (error) {
@@ -101,8 +158,25 @@ export class QualityAssessmentCoordinator {
             throw new Error(errorMsg);
         }
     }
+    /**
+     * V3 Integration: Initialize the consensus engine for multi-model verification
+     * @private
+     */
+    async initializeConsensus() {
+        try {
+            // The mixin handles provider registration and engine creation
+            await this.consensusMixin.initializeConsensus();
+            console.log('[quality-assessment] Consensus engine initialized for quality gate decisions');
+        }
+        catch (error) {
+            // Log and continue - consensus is enhancement, not critical
+            console.warn('[quality-assessment] Failed to initialize consensus engine:', error);
+            console.warn('[quality-assessment] Continuing without multi-model consensus verification');
+        }
+    }
     /**
      * Dispose and cleanup
+     * V3: Also disposes MinCut mixin and Consensus engine
      */
     async dispose() {
         await this.saveWorkflowState();
@@ -113,6 +187,10 @@ export class QualityAssessmentCoordinator {
             await this.qesona.close();
             this.qesona = undefined;
         }
+        // V3 Integration: Dispose MinCut mixin (ADR-047)
+        this.minCutMixin.dispose();
+        // V3 Integration: Dispose Consensus engine (CONSENSUS-MIXIN-001)
+        await this.consensusMixin.disposeConsensus();
         this.workflows.clear();
         this.initialized = false;
     }
@@ -123,16 +201,90 @@ export class QualityAssessmentCoordinator {
         return Array.from(this.workflows.values()).filter((w) => w.status === 'running' || w.status === 'pending');
     }
     // ============================================================================
+    // V3 Integration: MinCut Awareness (ADR-047)
+    // ============================================================================
+    /**
+     * Set the MinCut bridge for topology awareness
+     * Uses dependency injection pattern for testability
+     *
+     * @param bridge - The QueenMinCutBridge instance
+     */
+    setMinCutBridge(bridge) {
+        this.minCutMixin.setMinCutBridge(bridge);
+    }
+    /**
+     * Check if the overall topology is healthy
+     * Returns true if status is not 'critical'
+     */
+    isTopologyHealthy() {
+        return this.minCutMixin.isTopologyHealthy();
+    }
+    /**
+     * Get domains that are healthy for routing
+     * Filters out weak domains from routing candidates
+     */
+    getHealthyRoutingDomains() {
+        return this.minCutMixin.getHealthyRoutingDomains();
+    }
+    /**
+     * Check if this domain itself is a weak point in the topology
+     */
+    isDomainWeakPoint() {
+        return this.minCutMixin.isDomainWeakPoint();
+    }
+    /**
+     * Get weak vertices belonging to this domain
+     * Per ADR-047: Identifies agents that are single points of failure
+     */
+    getDomainWeakVertices() {
+        return this.minCutMixin.getDomainWeakVertices();
+    }
+    /**
+     * Get topology-aware routing for cross-domain coordination
+     * Per ADR-047: Routes to healthy domains, avoiding weak points
+     */
+    getTopologyBasedRouting(targetDomains) {
+        return this.minCutMixin.getTopologyBasedRouting(targetDomains);
+    }
+    // ============================================================================
+    // V3 Integration: Consensus Verification (CONSENSUS-MIXIN-001)
+    // ============================================================================
+    /**
+     * Get consensus statistics
+     */
+    getConsensusStats() {
+        return this.consensusMixin.getConsensusStats();
+    }
+    /**
+     * Check if consensus verification is available
+     */
+    isConsensusAvailable() {
+        return this.consensusMixin.isConsensusAvailable();
+    }
+    // ============================================================================
     // QualityAssessmentAPI Implementation
     // ============================================================================
     /**
      * Evaluate a quality gate
      * Uses Actor-Critic RL for intelligent threshold tuning when enabled
+     * V3: Uses consensus verification for borderline gate decisions
      */
     async evaluateGate(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'gate-evaluation');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Quality gate evaluation paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Quality gate evaluation paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health before proceeding (ADR-047)
+            // Apply stricter thresholds when topology is degraded
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded - applying stricter thresholds for quality gate');
+                // Continue evaluation but with heightened caution - quality gates are critical
+            }
             // Spawn quality gate agent if available
             const agentResult = await this.spawnQualityGateAgent(workflowId, request);
             if (agentResult.success) {
@@ -159,22 +311,31 @@ export class QualityAssessmentCoordinator {
                 this.failWorkflow(workflowId, 'Evaluation failed');
                 return result;
             }
+            // V3 Integration: Use consensus for borderline cases (CONSENSUS-MIXIN-001)
+            // Borderline cases are pass/fail decisions where metrics are close to thresholds
+            let finalResult = result.value;
+            if (this.config.enableConsensus && this.isBorderlineGateResult(request.metrics, request.thresholds, result.value)) {
+                const consensusResult = await this.verifyGateVerdictWithConsensus(effectiveRequest, result.value);
+                if (consensusResult) {
+                    finalResult = consensusResult;
+                }
+            }
             // Success path
             this.completeWorkflow(workflowId);
             // Store quality pattern in SONA if enabled
             if (this.config.enableSONAPatternLearning && this.qesona) {
-                await this.storeQualityPattern(effectiveRequest, result.value);
+                await this.storeQualityPattern(effectiveRequest, finalResult);
             }
             // Train Actor-Critic with the result
             if (this.config.enableRLThresholdTuning && this.actorCritic) {
-                await this.trainActorCritic(effectiveRequest, result.value);
+                await this.trainActorCritic(effectiveRequest, finalResult);
             }
             // Publish event
             if (this.config.publishEvents) {
-                await this.publishQualityGateEvaluated(result.value);
+                await this.publishQualityGateEvaluated(finalResult);
             }
             // V3: Verify claims before returning (Phase 4)
-            const verifiedResult = await this.verifyGateResultClaims(result.value);
+            const verifiedResult = await this.verifyGateResultClaims(finalResult);
             return ok(verifiedResult);
         }
         catch (error) {
@@ -182,14 +343,118 @@ export class QualityAssessmentCoordinator {
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * V3 Integration: Check if a gate result is a borderline case
+     * A borderline case is when any metric is within the configured margin of its threshold
+     *
+     * @param metrics - The quality metrics being evaluated
+     * @param thresholds - The threshold configuration
+     * @param result - The gate result
+     * @returns true if this is a borderline case requiring consensus
+     */
+    isBorderlineGateResult(metrics, thresholds, result) {
+        const margin = this.config.borderlineMargin;
+        // Check each metric against its threshold
+        const metricsToCheck = [
+            { metricKey: 'coverage', thresholdKey: 'coverage', isMin: true },
+            { metricKey: 'testsPassing', thresholdKey: 'testsPassing', isMin: true },
+            { metricKey: 'criticalBugs', thresholdKey: 'criticalBugs', isMin: false },
+            { metricKey: 'codeSmells', thresholdKey: 'codeSmells', isMin: false },
+            { metricKey: 'securityVulnerabilities', thresholdKey: 'securityVulnerabilities', isMin: false },
+            { metricKey: 'technicalDebt', thresholdKey: 'technicalDebt', isMin: false },
+            { metricKey: 'duplications', thresholdKey: 'duplications', isMin: false },
+        ];
+        for (const { metricKey, thresholdKey, isMin } of metricsToCheck) {
+            const metricValue = metrics[metricKey];
+            const thresholdConfig = thresholds[thresholdKey];
+            if (thresholdConfig === undefined)
+                continue;
+            const threshold = isMin
+                ? thresholdConfig.min
+                : thresholdConfig.max;
+            if (threshold === undefined || threshold === 0)
+                continue;
+            // Calculate relative distance from threshold
+            const relativeDistance = Math.abs(metricValue - threshold) / threshold;
+            // If any metric is within margin of threshold, it's borderline
+            if (relativeDistance < margin) {
+                console.log(`[quality-assessment] Borderline detected: ${metricKey}=${metricValue} (threshold=${threshold}, distance=${(relativeDistance * 100).toFixed(1)}%)`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * V3 Integration: Verify a gate verdict with multi-model consensus
+     *
+     * @param request - The gate evaluation request
+     * @param initialResult - The initial gate result
+     * @returns The potentially modified result with consensus verification, or null if consensus unavailable
+     */
+    async verifyGateVerdictWithConsensus(request, initialResult) {
+        // Create a domain finding for the gate verdict
+        const finding = createDomainFinding({
+            id: `gate-verdict-${uuidv4()}`,
+            type: 'gate-verdict',
+            confidence: initialResult.overallScore / 100,
+            description: `Quality gate '${request.gateName}' verdict: ${initialResult.passed ? 'PASSED' : 'FAILED'} (borderline case)`,
+            payload: {
+                metrics: request.metrics,
+                thresholds: request.thresholds,
+                initialResult,
+            },
+            detectedBy: 'quality-assessment-coordinator',
+            severity: initialResult.passed ? 'medium' : 'high',
+        });
+        // Check if this finding requires consensus
+        if (!this.consensusMixin.requiresConsensus(finding)) {
+            return null;
+        }
+        try {
+            const consensusResult = await this.consensusMixin.verifyFinding(finding);
+            if (!consensusResult.success) {
+                console.warn('[quality-assessment] Consensus verification failed:', consensusResult.error);
+                return null;
+            }
+            const consensus = consensusResult.value;
+            console.log(`[quality-assessment] Consensus for gate '${request.gateName}': ` +
+                `verdict=${consensus.verdict}, confidence=${(consensus.confidence * 100).toFixed(1)}%`);
+            // Return result with consensus information
+            return {
+                ...initialResult,
+                // Add consensus metadata (extends GateResult)
+                consensusVerified: true,
+                consensusConfidence: consensus.confidence,
+                consensusVerdict: consensus.verdict,
+            };
+        }
+        catch (error) {
+            console.error('[quality-assessment] Consensus verification error:', error);
+            return null;
+        }
+    }
     /**
      * Analyze code quality
      * Uses QEFlashAttention for similarity-based recommendations when enabled
+     * V3: Includes topology-aware behavior based on MinCut health
      */
     async analyzeQuality(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'quality-analysis');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Quality analysis paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Quality analysis paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health and adjust behavior (ADR-047)
+            const topologyHealthy = this.isTopologyHealthy();
+            if (!topologyHealthy) {
+                console.warn('[quality-assessment] Topology degraded during quality analysis');
+                // Could adjust analysis depth or timeouts in degraded state
+                // For now, we proceed but could be extended to reduce analysis scope
+            }
             // Spawn quality analyzer agent
             const agentResult = await this.spawnQualityAnalyzerAgent(workflowId, request);
             if (agentResult.success) {
@@ -234,11 +499,22 @@ export class QualityAssessmentCoordinator {
     }
     /**
      * Get deployment recommendation
+     * V3: Uses consensus verification for high-risk deployment decisions
      */
     async getDeploymentAdvice(request) {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'deployment-advice');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Deployment advice paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Deployment advice paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health (ADR-047)
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded during deployment advice generation');
+            }
             // Spawn deployment advisor agent
             const agentResult = await this.spawnDeploymentAdvisorAgent(workflowId, request);
             if (agentResult.success) {
@@ -254,19 +530,83 @@ export class QualityAssessmentCoordinator {
                 this.failWorkflow(workflowId, 'Evaluation failed');
                 return result;
             }
+            // V3 Integration: Use consensus for high-risk deployment decisions (CONSENSUS-MIXIN-001)
+            let finalAdvice = result.value;
+            if (this.config.enableConsensus && this.isHighRiskDeployment(request, result.value)) {
+                const consensusAdvice = await this.verifyDeploymentAdviceWithConsensus(request, result.value);
+                if (consensusAdvice) {
+                    finalAdvice = consensusAdvice;
+                }
+            }
             // Success path
             this.completeWorkflow(workflowId);
             // Publish deployment decision event
             if (this.config.publishEvents) {
-                await this.publishDeploymentDecision(result.value, request.releaseCandidate);
+                await this.publishDeploymentDecision(finalAdvice, request.releaseCandidate);
             }
-            return result;
+            return ok(finalAdvice);
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
             return err(error instanceof Error ? error : new Error(String(error)));
         }
     }
+    /**
+     * V3 Integration: Check if a deployment is high-risk
+     * High-risk deployments include blocked deployments or low risk tolerance with warnings
+     */
+    isHighRiskDeployment(request, advice) {
+        // Blocked deployments are always high-risk
+        if (advice.decision === 'blocked') {
+            return true;
+        }
+        // Warning with low risk tolerance is high-risk
+        if (advice.decision === 'warning' && request.riskTolerance === 'low') {
+            return true;
+        }
+        // High risk score (>0.7) with any decision is high-risk
+        if (advice.riskScore > 0.7) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * V3 Integration: Verify deployment advice with multi-model consensus
+     */
+    async verifyDeploymentAdviceWithConsensus(request, initialAdvice) {
+        const finding = createDomainFinding({
+            id: `release-readiness-${uuidv4()}`,
+            type: 'release-readiness',
+            confidence: initialAdvice.confidence,
+            description: `Release readiness for '${request.releaseCandidate}': ${initialAdvice.decision} (risk: ${(initialAdvice.riskScore * 100).toFixed(0)}%)`,
+            payload: { request, initialAdvice },
+            detectedBy: 'quality-assessment-coordinator',
+            severity: initialAdvice.decision === 'blocked' ? 'critical' : 'high',
+        });
+        if (!this.consensusMixin.requiresConsensus(finding)) {
+            return null;
+        }
+        try {
+            const consensusResult = await this.consensusMixin.verifyFinding(finding);
+            if (!consensusResult.success) {
+                console.warn('[quality-assessment] Consensus verification for deployment failed:', consensusResult.error);
+                return null;
+            }
+            const consensus = consensusResult.value;
+            console.log(`[quality-assessment] Consensus for deployment '${request.releaseCandidate}': ` +
+                `verdict=${consensus.verdict}, confidence=${(consensus.confidence * 100).toFixed(1)}%`);
+            return {
+                ...initialAdvice,
+                consensusVerified: true,
+                consensusConfidence: consensus.confidence,
+                consensusVerdict: consensus.verdict,
+            };
+        }
+        catch (error) {
+            console.error('[quality-assessment] Consensus verification error:', error);
+            return null;
+        }
+    }
     /**
      * Analyze code complexity
      */
@@ -274,6 +614,16 @@ export class QualityAssessmentCoordinator {
         const workflowId = uuidv4();
         try {
             this.startWorkflow(workflowId, 'complexity-analysis');
+            // Self-healing: Check if operations should be paused due to critical topology
+            if (this.minCutMixin.shouldPauseOperations()) {
+                console.warn('[quality-assessment] Complexity analysis paused: topology is in critical state');
+                this.failWorkflow(workflowId, 'Topology is in critical state');
+                return err(new Error('Complexity analysis paused: topology is in critical state'));
+            }
+            // V3 Integration: Check topology health (ADR-047)
+            if (!this.isTopologyHealthy()) {
+                console.warn('[quality-assessment] Topology degraded during complexity analysis');
+            }
             // Spawn complexity analyzer agent
             const agentResult = await this.spawnComplexityAnalyzerAgent(workflowId, request);
             if (agentResult.success) {
@@ -446,6 +796,142 @@ export class QualityAssessmentCoordinator {
         this.eventBus.subscribe('coverage-analysis.CoverageReportCreated', this.handleCoverageReportCreated.bind(this));
         // Subscribe to security events
         this.eventBus.subscribe('security-compliance.SecurityAuditCompleted', this.handleSecurityAuditCompleted.bind(this));
+        // Subscribe to dream cycle events from learning-optimization domain
+        this.subscribeToDreamEvents();
+    }
+    // ============================================================================
+    // Dream Event Handling (ADR-021 Integration)
+    // ============================================================================
+    /**
+     * Subscribe to dream cycle completion events from learning-optimization domain.
+     * Dream insights can suggest quality improvements, threshold adjustments, and risk patterns.
+     */
+    subscribeToDreamEvents() {
+        this.eventBus.subscribe(LearningOptimizationEvents.DreamCycleCompleted, this.handleDreamCycleCompleted.bind(this));
+    }
+    /**
+     * Handle dream cycle completion event.
+     * Filters insights relevant to quality assessment and applies actionable ones.
+     */
+    async handleDreamCycleCompleted(event) {
+        const { insights, cycleId } = event.payload;
+        if (!insights || insights.length === 0) {
+            return;
+        }
+        // Filter insights relevant to this domain
+        const relevantInsights = insights.filter((insight) => {
+            // Check if suggested action mentions this domain
+            const actionRelevant = insight.suggestedAction?.toLowerCase().includes(this.domain) ||
+                insight.suggestedAction?.toLowerCase().includes('quality') ||
+                insight.suggestedAction?.toLowerCase().includes('gate') ||
+                insight.suggestedAction?.toLowerCase().includes('threshold');
+            // Check if source concepts include quality-related terms
+            const conceptsRelevant = insight.sourceConcepts.some((c) => c.toLowerCase().includes('quality') ||
+                c.toLowerCase().includes(this.domain) ||
+                c.toLowerCase().includes('metric') ||
+                c.toLowerCase().includes('gate'));
+            // Check for quality-assessment related insight types
+            const typeRelevant = insight.type === 'optimization' || insight.type === 'pattern_merge';
+            return actionRelevant || conceptsRelevant || (typeRelevant && insight.actionable);
+        });
+        if (relevantInsights.length === 0) {
+            return;
+        }
+        console.log(`[${this.domain}] Received ${relevantInsights.length} relevant dream insights from cycle ${cycleId}`);
+        // Apply high-confidence actionable insights
+        for (const insight of relevantInsights) {
+            if (insight.confidenceScore > 0.7 && insight.actionable) {
+                await this.applyDreamInsight(insight, cycleId);
+            }
+            // Cache all relevant insights for quality enhancement
+            this.recentDreamInsights.push({
+                ...insight,
+                receivedAt: new Date(),
+            });
+        }
+        // Prune old insights (keep last 50)
+        if (this.recentDreamInsights.length > 50) {
+            this.recentDreamInsights = this.recentDreamInsights.slice(-50);
+        }
+    }
+    /**
+     * Apply a dream insight by storing it as a learned pattern via SONA.
+     * This allows the insight to influence future quality assessment decisions.
+     *
+     * @param insight - The dream insight to apply
+     * @param cycleId - The dream cycle ID for tracking
+     */
+    async applyDreamInsight(insight, cycleId) {
+        console.log(`[${this.domain}] Applying dream insight: ${insight.description.slice(0, 100)}...`);
+        // Store as a learned pattern via SONA if available
+        if (this.qesona) {
+            try {
+                // Create state representation from insight
+                const state = {
+                    id: `dream-insight-${insight.id}`,
+                    features: this.encodeInsightAsFeatures(insight),
+                    metadata: {
+                        insightType: insight.type,
+                        cycleId,
+                        sourceConcepts: insight.sourceConcepts,
+                    },
+                };
+                // Create action representing the suggested action
+                const action = {
+                    type: 'dream-insight',
+                    value: insight.suggestedAction || insight.description,
+                };
+                // Create pattern in QESONA with dream-derived marker
+                this.qesona.createPattern(state, action, {
+                    reward: insight.confidenceScore,
+                    success: true,
+                    quality: insight.noveltyScore,
+                }, 'quality-assessment', this.domain, {
+                    insightId: insight.id,
+                    cycleId,
+                    description: insight.description,
+                    suggestedAction: insight.suggestedAction,
+                    dreamDerived: true,
+                });
+                console.log(`[${this.domain}] Created SONA pattern from dream insight ${insight.id}`);
+            }
+            catch (error) {
+                console.error(`[${this.domain}] Failed to store dream insight pattern:`, error);
+            }
+        }
+        // Store insight in memory for downstream usage
+        await this.memory.set(`${this.domain}:dream-insight:${insight.id}`, {
+            insight,
+            cycleId,
+            appliedAt: new Date().toISOString(),
+        }, { namespace: this.domain, ttl: 86400 * 7 } // 7 days
+        );
+    }
+    /**
+     * Encode a dream insight as feature vector for SONA pattern creation.
+     */
+    encodeInsightAsFeatures(insight) {
+        const features = [];
+        // Encode insight type
+        const typeMap = {
+            pattern_merge: 0.2,
+            novel_association: 0.4,
+            optimization: 0.6,
+            gap_detection: 0.8,
+        };
+        features.push(typeMap[insight.type] || 0.5);
+        // Encode confidence and novelty
+        features.push(insight.confidenceScore);
+        features.push(insight.noveltyScore);
+        // Encode actionability
+        features.push(insight.actionable ? 1.0 : 0.0);
+        // Encode source concept count (normalized)
+        features.push(Math.min(1, insight.sourceConcepts.length / 10));
+        // Pad to consistent size
+        while (features.length < 384) {
+            features.push(0);
+        }
+        return features.slice(0, 384);
     }
     async handleTestRunCompleted(event) {
         // Auto-evaluate quality gate after test run if enabled