agentic-qe 3.6.8 → 3.6.9

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

@@ -3,20 +3,18 @@
  * Orchestrates learning workflows across all QE domains
  */
 import { v4 as uuidv4 } from 'uuid';
+import { toError } from '../../shared/error-utils.js';
 import { ok, err, ALL_DOMAINS, } from '../../shared/types/index.js';
 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';
-// ADR-058: Governance-aware mixin for MemoryWriteGate integration
-import { createGovernanceAwareMixin, } from '../../coordination/mixins/governance-aware-domain.js';
-import { createDomainFinding, } from '../../coordination/consensus/domain-findings.js';
+// CQ-002: Base domain coordinator
+import { BaseDomainCoordinator, } from '../base-domain-coordinator.js';
+// CQ-004: Extracted modules
+import * as LearningHelpers from './coordinator-helpers.js';
+import * as ConsensusHelpers from './coordinator-consensus.js';
 const DEFAULT_CONFIG = {
     maxConcurrentWorkflows: 3,
     defaultTimeout: 120000, // 2 minutes
@@ -42,20 +40,15 @@ const DEFAULT_CONFIG = {
     consensusMinModels: 2,
 };
 /**
- * Learning & Optimization Coordinator
- * Orchestrates cross-domain learning and optimization workflows
+ * CQ-002: Extends BaseDomainCoordinator
  */
-export class LearningOptimizationCoordinator {
-    eventBus;
+export class LearningOptimizationCoordinator extends BaseDomainCoordinator {
     memory;
     agentCoordinator;
-    config;
-    workflows = new Map();
     learningService;
     transferService;
     optimizerService;
     productionIntel;
-    initialized = false;
     /**
      * QESONA (Self-Optimizing Neural Architecture) for pattern learning
      * Provides <0.05ms pattern adaptation via @ruvector/sona
@@ -67,50 +60,27 @@ export class LearningOptimizationCoordinator {
      * 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';
-    // ADR-058: Governance mixin for MemoryWriteGate integration
-    governanceMixin;
     constructor(eventBus, memory, agentCoordinator, config = {}) {
-        this.eventBus = eventBus;
-        this.memory = memory;
-        this.agentCoordinator = agentCoordinator;
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // 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,
+        const fullConfig = { ...DEFAULT_CONFIG, ...config };
+        super(eventBus, 'learning-optimization', fullConfig, {
             verifyFindingTypes: ['pattern-recommendation', 'optimization-suggestion', 'cross-domain-insight'],
-            strategy: this.config.consensusStrategy,
-            minModels: this.config.consensusMinModels,
-            modelTimeout: 60000,
-            verifySeverities: ['critical', 'high'],
-            enableLogging: false,
         });
-        // ADR-058: Initialize governance mixin for MemoryWriteGate integration
-        this.governanceMixin = createGovernanceAwareMixin(this.domainName);
+        this.memory = memory;
+        this.agentCoordinator = agentCoordinator;
         this.learningService = new LearningCoordinatorService({ memory });
         this.transferService = new TransferSpecialistService(memory);
         this.optimizerService = new MetricsOptimizerService(memory);
         this.productionIntel = new ProductionIntelService(memory);
     }
+    // ==========================================================================
+    // BaseDomainCoordinator Template Methods
+    // ==========================================================================
     /**
      * Initialize the coordinator.
+     * CQ-002: Domain-specific initialization
      * Throws if QESONA fails to initialize.
      */
-    async initialize() {
-        if (this.initialized)
-            return;
+    async onInitialize() {
         // Initialize QESONA for neural pattern learning (persistent patterns)
         try {
             this.sona = await createPersistentSONAEngine({
@@ -156,36 +126,14 @@ export class LearningOptimizationCoordinator {
         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
+     * CQ-002: Domain-specific disposal
      */
-    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();
+    async onDispose() {
         // Save workflow state
         await this.saveWorkflowState();
-        // Clear active workflows
-        this.workflows.clear();
         // Dispose DreamScheduler
         if (this.dreamScheduler) {
             try {
@@ -206,13 +154,12 @@ export class LearningOptimizationCoordinator {
                 console.error('[LearningOptimizationCoordinator] Error closing SONA engine:', error);
             }
         }
-        this.initialized = false;
     }
     /**
-     * Get active workflow statuses
+     * Get active workflow statuses (typed override)
      */
     getActiveWorkflows() {
-        return Array.from(this.workflows.values()).filter((w) => w.status === 'running' || w.status === 'pending');
+        return super.getActiveWorkflows();
     }
     // ============================================================================
     // ILearningOptimizationCoordinator Implementation
@@ -305,7 +252,7 @@ export class LearningOptimizationCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -372,7 +319,7 @@ export class LearningOptimizationCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -454,7 +401,7 @@ export class LearningOptimizationCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -516,7 +463,7 @@ export class LearningOptimizationCoordinator {
             return ok(dashboard);
         }
         catch (error) {
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     // ============================================================================
@@ -805,7 +752,7 @@ export class LearningOptimizationCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     /**
@@ -937,7 +884,7 @@ export class LearningOptimizationCoordinator {
         }
         catch (error) {
             this.failWorkflow(workflowId, String(error));
-            return err(error instanceof Error ? error : new Error(String(error)));
+            return err(toError(error));
         }
     }
     // ============================================================================
@@ -1192,51 +1139,6 @@ export class LearningOptimizationCoordinator {
         return this.agentCoordinator.spawn(config);
     }
     // ============================================================================
-    // Workflow Management
-    // ============================================================================
-    startWorkflow(id, type) {
-        const activeWorkflows = this.getActiveWorkflows();
-        if (activeWorkflows.length >= this.config.maxConcurrentWorkflows) {
-            throw new Error(`Maximum concurrent workflows (${this.config.maxConcurrentWorkflows}) reached`);
-        }
-        this.workflows.set(id, {
-            id,
-            type,
-            status: 'running',
-            startedAt: new Date(),
-            agentIds: [],
-            progress: 0,
-        });
-    }
-    completeWorkflow(id) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.status = 'completed';
-            workflow.completedAt = new Date();
-            workflow.progress = 100;
-        }
-    }
-    failWorkflow(id, error) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.status = 'failed';
-            workflow.completedAt = new Date();
-            workflow.error = error;
-        }
-    }
-    addAgentToWorkflow(workflowId, agentId) {
-        const workflow = this.workflows.get(workflowId);
-        if (workflow) {
-            workflow.agentIds.push(agentId);
-        }
-    }
-    updateWorkflowProgress(id, progress) {
-        const workflow = this.workflows.get(id);
-        if (workflow) {
-            workflow.progress = Math.min(100, Math.max(0, progress));
-        }
-    }
-    // ============================================================================
     // State Persistence
     // ============================================================================
     async loadWorkflowState() {
@@ -1293,139 +1195,23 @@ export class LearningOptimizationCoordinator {
         };
     }
     async storeStrategy(domain, strategy) {
-        await this.memory.set(`learning:strategy:current:${domain}`, strategy, {
-            namespace: 'learning-optimization',
-            persist: true,
-        });
+        await LearningHelpers.storeStrategy(this.memory, domain, strategy);
     }
     calculateMetricValue(experiences, metric) {
-        const values = experiences
-            .map((e) => e.result.outcome[metric] ?? 0)
-            .filter((v) => !isNaN(v));
-        if (values.length === 0)
-            return 0;
-        return values.reduce((a, b) => a + b, 0) / values.length;
+        return LearningHelpers.calculateMetricValue(experiences, metric);
     }
     getRelatedDomains(domain) {
-        const relationships = {
-            'test-generation': ['test-execution', 'coverage-analysis'],
-            'test-execution': ['test-generation', 'coverage-analysis', 'quality-assessment'],
-            'coverage-analysis': ['test-generation', 'test-execution', 'quality-assessment'],
-            'quality-assessment': ['test-execution', 'coverage-analysis', 'defect-intelligence'],
-            'defect-intelligence': ['quality-assessment', 'code-intelligence'],
-            'requirements-validation': ['test-generation', 'quality-assessment'],
-            'code-intelligence': ['defect-intelligence', 'security-compliance'],
-            'security-compliance': ['code-intelligence', 'quality-assessment'],
-            'contract-testing': ['test-generation', 'test-execution'],
-            'visual-accessibility': ['quality-assessment'],
-            'chaos-resilience': ['test-execution', 'quality-assessment'],
-            'learning-optimization': ALL_DOMAINS.filter((d) => d !== 'learning-optimization'),
-            'enterprise-integration': ['contract-testing', 'security-compliance', 'quality-assessment'],
-            'coordination': ALL_DOMAINS.filter((d) => d !== 'coordination'),
-        };
-        return relationships[domain] || [];
+        return LearningHelpers.getRelatedDomains(domain);
     }
     findSimilarPatterns(patterns) {
-        const groups = [];
-        const assigned = new Set();
-        for (const pattern of patterns) {
-            if (assigned.has(pattern.id))
-                continue;
-            const group = [pattern];
-            assigned.add(pattern.id);
-            for (const other of patterns) {
-                if (assigned.has(other.id))
-                    continue;
-                if (pattern.type === other.type &&
-                    pattern.domain === other.domain &&
-                    this.contextsOverlap(pattern.context, other.context)) {
-                    group.push(other);
-                    assigned.add(other.id);
-                }
-            }
-            if (group.length >= 2) {
-                groups.push(group);
-            }
-        }
-        return groups;
-    }
-    contextsOverlap(a, b) {
-        return a.tags.some((tag) => b.tags.includes(tag));
+        return LearningHelpers.findSimilarPatterns(patterns);
     }
     calculateChecksum(patterns, knowledge, strategies) {
-        const data = JSON.stringify({
-            patternCount: patterns.length,
-            knowledgeCount: knowledge.length,
-            strategyCount: strategies.length,
-            patternIds: patterns.map((p) => p.id).sort(),
-            knowledgeIds: knowledge.map((k) => k.id).sort(),
-            strategyIds: strategies.map((s) => s.id).sort(),
-        });
-        // Simple hash function
-        let hash = 0;
-        for (let i = 0; i < data.length; i++) {
-            const char = data.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash;
-        }
-        return Math.abs(hash).toString(16);
+        return LearningHelpers.calculateChecksum(patterns, knowledge, strategies);
     }
     // ============================================================================
-    // MinCut Integration Methods (ADR-047)
+    // Domain-Specific Consensus Methods (MM-001)
     // ============================================================================
-    /**
-     * 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
@@ -1435,83 +1221,13 @@ export class LearningOptimizationCoordinator {
      * @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
+        return ConsensusHelpers.verifyPatternRecommendation(pattern, confidence, this.consensusMixin, this.domainName);
     }
-    /**
-     * 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
+        return ConsensusHelpers.verifyOptimizationSuggestion(suggestion, confidence, this.consensusMixin, this.domainName);
     }
-    /**
-     * 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
+        return ConsensusHelpers.verifyCrossDomainInsight(insight, confidence, this.consensusMixin, this.domainName);
     }
 }
 //# sourceMappingURL=coordinator.js.map