@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/domains/learning-optimization/coordinator.ts

@@ -1,1215 +0,0 @@
-/**
- * Agentic QE v3 - Learning & Optimization Coordinator
- * Orchestrates learning workflows across all QE domains
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import {
-  Result,
-  ok,
-  err,
-  DomainName,
-  ALL_DOMAINS,
-} from '../../shared/types/index.js';
-import {
-  EventBus,
-  MemoryBackend,
-  AgentCoordinator,
-  AgentSpawnConfig,
-} from '../../kernel/interfaces.js';
-import { TimeRange } from '../../shared/value-objects/index.js';
-import {
-  LearningOptimizationEvents,
-  PatternConsolidatedPayload,
-  TransferCompletedPayload,
-  createEvent,
-} from '../../shared/events/domain-events.js';
-import {
-  ILearningOptimizationCoordinator,
-  LearningCycleReport,
-  OptimizationReport,
-  CrossDomainSharingReport,
-  LearningDashboard,
-  ModelExport,
-  ImportReport,
-  ImportConflict,
-  Improvement,
-  DomainOptimizationResult,
-  LearnedPattern,
-  Knowledge,
-  OptimizedStrategy,
-  Experience,
-  OptimizationObjective,
-} from './interfaces.js';
-import {
-  LearningCoordinatorService,
-  TransferSpecialistService,
-  MetricsOptimizerService,
-  ProductionIntelService,
-} from './services/index.js';
-
-/**
- * Workflow status tracking
- */
-export interface LearningWorkflowStatus {
-  id: string;
-  type: 'learning-cycle' | 'optimization' | 'transfer' | 'export' | 'import';
-  status: 'pending' | 'running' | 'completed' | 'failed';
-  startedAt: Date;
-  completedAt?: Date;
-  agentIds: string[];
-  progress: number;
-  error?: string;
-}
-
-/**
- * Coordinator configuration
- */
-export interface LearningCoordinatorConfig {
-  maxConcurrentWorkflows: number;
-  defaultTimeout: number;
-  enableAutoOptimization: boolean;
-  publishEvents: boolean;
-  learningCycleIntervalMs: number;
-}
-
-const DEFAULT_CONFIG: LearningCoordinatorConfig = {
-  maxConcurrentWorkflows: 3,
-  defaultTimeout: 120000, // 2 minutes
-  enableAutoOptimization: true,
-  publishEvents: true,
-  learningCycleIntervalMs: 3600000, // 1 hour
-};
-
-/**
- * Learning & Optimization Coordinator
- * Orchestrates cross-domain learning and optimization workflows
- */
-export class LearningOptimizationCoordinator
-  implements ILearningOptimizationCoordinator
-{
-  private readonly config: LearningCoordinatorConfig;
-  private readonly workflows: Map<string, LearningWorkflowStatus> = new Map();
-  private readonly learningService: LearningCoordinatorService;
-  private readonly transferService: TransferSpecialistService;
-  private readonly optimizerService: MetricsOptimizerService;
-  private readonly productionIntel: ProductionIntelService;
-  private initialized = false;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    private readonly memory: MemoryBackend,
-    private readonly agentCoordinator: AgentCoordinator,
-    config: Partial<LearningCoordinatorConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    this.learningService = new LearningCoordinatorService(memory);
-    this.transferService = new TransferSpecialistService(memory);
-    this.optimizerService = new MetricsOptimizerService(memory);
-    this.productionIntel = new ProductionIntelService(memory);
-  }
-
-  /**
-   * Initialize the coordinator
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) return;
-
-    // Subscribe to relevant events
-    this.subscribeToEvents();
-
-    // Load any persisted workflow state
-    await this.loadWorkflowState();
-
-    this.initialized = true;
-  }
-
-  /**
-   * Dispose and cleanup
-   */
-  async dispose(): Promise<void> {
-    // Save workflow state
-    await this.saveWorkflowState();
-
-    // Clear active workflows
-    this.workflows.clear();
-
-    this.initialized = false;
-  }
-
-  /**
-   * Get active workflow statuses
-   */
-  getActiveWorkflows(): LearningWorkflowStatus[] {
-    return Array.from(this.workflows.values()).filter(
-      (w) => w.status === 'running' || w.status === 'pending'
-    );
-  }
-
-  // ============================================================================
-  // ILearningOptimizationCoordinator Implementation
-  // ============================================================================
-
-  /**
-   * Run a learning cycle for a specific domain
-   */
-  async runLearningCycle(domain: DomainName): Promise<Result<LearningCycleReport>> {
-    const workflowId = uuidv4();
-
-    try {
-      this.startWorkflow(workflowId, 'learning-cycle');
-
-      // Spawn learning agent
-      const agentResult = await this.spawnLearningAgent(workflowId, domain);
-      if (!agentResult.success) {
-        this.failWorkflow(workflowId, agentResult.error.message);
-        return err(agentResult.error);
-      }
-
-      this.addAgentToWorkflow(workflowId, agentResult.value);
-
-      // Get experiences from the last cycle
-      const timeRange = TimeRange.lastNDays(1);
-      const experiencesResult = await this.getExperiencesForDomain(domain, timeRange);
-      const experiences = experiencesResult.success ? experiencesResult.value : [];
-
-      this.updateWorkflowProgress(workflowId, 20);
-
-      // Mine experiences for patterns
-      const insightsResult = await this.learningService.mineExperiences(
-        domain,
-        timeRange
-      );
-      const patternsLearned = insightsResult.success
-        ? insightsResult.value.patterns.length
-        : 0;
-
-      this.updateWorkflowProgress(workflowId, 50);
-
-      // Optimize strategies based on experiences
-      let strategiesOptimized = 0;
-      const improvements: Improvement[] = [];
-
-      if (experiences.length >= 10) {
-        const objective: OptimizationObjective = {
-          metric: 'success_rate',
-          direction: 'maximize',
-          constraints: [],
-        };
-
-        const currentStrategy = await this.getCurrentStrategy(domain);
-        const optimizationResult = await this.optimizerService.optimizeStrategy(
-          currentStrategy,
-          objective,
-          experiences
-        );
-
-        if (optimizationResult.success) {
-          strategiesOptimized = 1;
-          improvements.push({
-            metric: objective.metric,
-            before: this.calculateMetricValue(experiences, objective.metric),
-            after: optimizationResult.value.optimizedStrategy.expectedOutcome[objective.metric] || 0,
-            percentChange: optimizationResult.value.improvement * 100,
-          });
-        }
-      }
-
-      this.updateWorkflowProgress(workflowId, 80);
-
-      // Generate knowledge from insights
-      let knowledgeGenerated = 0;
-      if (insightsResult.success && insightsResult.value.recommendations.length > 0) {
-        const knowledgeResult = await this.transferService.createKnowledge(
-          'heuristic',
-          domain,
-          insightsResult.value.recommendations,
-          {
-            value: `learning-agent-${workflowId.slice(0, 8)}`,
-            domain: 'learning-optimization',
-            type: 'analyzer',
-          },
-          [domain]
-        );
-
-        if (knowledgeResult.success) {
-          knowledgeGenerated = 1;
-        }
-      }
-
-      // Complete workflow
-      this.completeWorkflow(workflowId);
-
-      // Stop agent
-      await this.agentCoordinator.stop(agentResult.value);
-
-      const report: LearningCycleReport = {
-        domain,
-        experiencesProcessed: experiences.length,
-        patternsLearned,
-        strategiesOptimized,
-        knowledgeGenerated,
-        improvements,
-      };
-
-      // Publish event
-      if (this.config.publishEvents && patternsLearned > 0) {
-        await this.publishPatternConsolidated(patternsLearned, [domain]);
-      }
-
-      return ok(report);
-    } catch (error) {
-      this.failWorkflow(workflowId, String(error));
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Optimize all domain strategies
-   */
-  async optimizeAllStrategies(): Promise<Result<OptimizationReport>> {
-    const workflowId = uuidv4();
-
-    try {
-      this.startWorkflow(workflowId, 'optimization');
-
-      const byDomain: Record<DomainName, DomainOptimizationResult> = {} as Record<
-        DomainName,
-        DomainOptimizationResult
-      >;
-      let totalStrategies = 0;
-      let totalImprovement = 0;
-      let domainsOptimized = 0;
-
-      const targetDomains = ALL_DOMAINS.filter(
-        (d) => d !== 'learning-optimization'
-      );
-
-      for (let i = 0; i < targetDomains.length; i++) {
-        const domain = targetDomains[i];
-        this.updateWorkflowProgress(
-          workflowId,
-          Math.round((i / targetDomains.length) * 100)
-        );
-
-        const timeRange = TimeRange.lastNDays(7);
-        const experiencesResult = await this.getExperiencesForDomain(
-          domain,
-          timeRange
-        );
-
-        if (!experiencesResult.success || experiencesResult.value.length < 10) {
-          continue;
-        }
-
-        const experiences = experiencesResult.value;
-        const objective: OptimizationObjective = {
-          metric: 'success_rate',
-          direction: 'maximize',
-          constraints: [],
-        };
-
-        const currentStrategy = await this.getCurrentStrategy(domain);
-        const optimizationResult = await this.optimizerService.optimizeStrategy(
-          currentStrategy,
-          objective,
-          experiences
-        );
-
-        if (optimizationResult.success) {
-          totalStrategies++;
-          totalImprovement += optimizationResult.value.improvement;
-          domainsOptimized++;
-
-          byDomain[domain] = {
-            strategiesOptimized: 1,
-            avgImprovement: optimizationResult.value.improvement,
-            bestStrategy: optimizationResult.value.optimizedStrategy,
-          };
-
-          // Store as current strategy
-          await this.storeStrategy(domain, optimizationResult.value.optimizedStrategy);
-        }
-      }
-
-      this.completeWorkflow(workflowId);
-
-      const report: OptimizationReport = {
-        domainsOptimized,
-        totalStrategies,
-        avgImprovement: totalStrategies > 0 ? totalImprovement / totalStrategies : 0,
-        byDomain,
-      };
-
-      // Publish event
-      if (this.config.publishEvents && totalStrategies > 0) {
-        await this.publishOptimizationApplied(report);
-      }
-
-      return ok(report);
-    } catch (error) {
-      this.failWorkflow(workflowId, String(error));
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Share learnings across domains
-   */
-  async shareCrossDomainLearnings(): Promise<Result<CrossDomainSharingReport>> {
-    const workflowId = uuidv4();
-
-    try {
-      this.startWorkflow(workflowId, 'transfer');
-
-      let knowledgeShared = 0;
-      const domainsUpdated: DomainName[] = [];
-      let newPatternsCreated = 0;
-      let totalTransfers = 0;
-      let successfulTransfers = 0;
-
-      // Get all knowledge items
-      const queryResult = await this.transferService.queryKnowledge({
-        minRelevance: 0.7,
-        limit: 100,
-      });
-
-      if (!queryResult.success) {
-        this.failWorkflow(workflowId, queryResult.error.message);
-        return err(queryResult.error);
-      }
-
-      const knowledgeItems = queryResult.value;
-
-      // Transfer high-relevance knowledge to related domains
-      for (const knowledge of knowledgeItems) {
-        const targetDomains = this.getRelatedDomains(knowledge.domain);
-
-        for (const targetDomain of targetDomains) {
-          if (targetDomain === knowledge.domain) continue;
-
-          totalTransfers++;
-          const transferResult = await this.transferService.transferKnowledge(
-            knowledge,
-            targetDomain
-          );
-
-          if (transferResult.success) {
-            successfulTransfers++;
-            knowledgeShared++;
-
-            if (!domainsUpdated.includes(targetDomain)) {
-              domainsUpdated.push(targetDomain);
-            }
-          }
-        }
-
-        this.updateWorkflowProgress(
-          workflowId,
-          Math.round((knowledgeShared / (knowledgeItems.length * 2)) * 100)
-        );
-      }
-
-      // Consolidate similar patterns
-      const patternStatsResult = await this.learningService.getPatternStats();
-      if (patternStatsResult.success) {
-        const topPatterns = patternStatsResult.value.topPatterns;
-        if (topPatterns.length >= 2) {
-          const similarPatterns = this.findSimilarPatterns(topPatterns);
-
-          for (const group of similarPatterns) {
-            if (group.length >= 2) {
-              const consolidateResult = await this.learningService.consolidatePatterns(
-                group.map((p) => p.id)
-              );
-              if (consolidateResult.success) {
-                newPatternsCreated++;
-              }
-            }
-          }
-        }
-      }
-
-      this.completeWorkflow(workflowId);
-
-      const report: CrossDomainSharingReport = {
-        knowledgeShared,
-        domainsUpdated,
-        transferSuccessRate:
-          totalTransfers > 0 ? successfulTransfers / totalTransfers : 1,
-        newPatternsCreated,
-      };
-
-      // Publish event
-      if (this.config.publishEvents && knowledgeShared > 0) {
-        await this.publishTransferCompleted(report);
-      }
-
-      return ok(report);
-    } catch (error) {
-      this.failWorkflow(workflowId, String(error));
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get learning dashboard
-   */
-  async getLearningDashboard(): Promise<Result<LearningDashboard>> {
-    try {
-      // Get pattern stats
-      const patternStatsResult = await this.learningService.getPatternStats();
-      const patternStats = patternStatsResult.success
-        ? patternStatsResult.value
-        : null;
-
-      // Get knowledge count
-      const knowledgeResult = await this.transferService.queryKnowledge({
-        limit: 1000,
-      });
-      const totalKnowledge = knowledgeResult.success
-        ? knowledgeResult.value.length
-        : 0;
-
-      // Get experiences from last 24h
-      const timeRange = TimeRange.lastNDays(1);
-      let experiencesLast24h = 0;
-      for (const domain of ALL_DOMAINS) {
-        const expResult = await this.getExperiencesForDomain(domain, timeRange);
-        if (expResult.success) {
-          experiencesLast24h += expResult.value.length;
-        }
-      }
-
-      // Get production health for trends
-      const healthResult = await this.productionIntel.getProductionHealth();
-      const trends = healthResult.success ? healthResult.value.trends : [];
-
-      // Get milestones
-      const milestonesResult = await this.productionIntel.getRecentMilestones(5);
-      const recentMilestones = milestonesResult.success
-        ? milestonesResult.value
-        : [];
-
-      // Calculate overall learning rate
-      const overallLearningRate = patternStats
-        ? patternStats.avgSuccessRate * 0.6 + (patternStats.avgConfidence * 0.4)
-        : 0.5;
-
-      // Determine top performing domains
-      const topPerformingDomains: DomainName[] = [];
-      if (patternStats) {
-        const domainScores = Object.entries(patternStats.byDomain)
-          .filter(([_, count]) => count > 0)
-          .map(([domain, count]) => ({ domain: domain as DomainName, score: count }))
-          .sort((a, b) => b.score - a.score);
-
-        topPerformingDomains.push(...domainScores.slice(0, 3).map((d) => d.domain));
-      }
-
-      const dashboard: LearningDashboard = {
-        overallLearningRate,
-        totalPatterns: patternStats?.totalPatterns || 0,
-        totalKnowledge,
-        experiencesLast24h,
-        topPerformingDomains,
-        learningTrend: trends,
-        recentMilestones,
-      };
-
-      return ok(dashboard);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Export learned models
-   */
-  async exportModels(domains?: DomainName[]): Promise<Result<ModelExport>> {
-    const workflowId = uuidv4();
-
-    try {
-      this.startWorkflow(workflowId, 'export');
-
-      const targetDomains = domains || ALL_DOMAINS;
-      const patterns: LearnedPattern[] = [];
-      const knowledge: Knowledge[] = [];
-      const strategies: OptimizedStrategy[] = [];
-
-      // Export patterns
-      for (const _domain of targetDomains) {
-        const patternKeys = await this.memory.search(
-          `learning:pattern:*`,
-          500
-        );
-
-        for (const key of patternKeys) {
-          const pattern = await this.memory.get<LearnedPattern>(key);
-          if (pattern && targetDomains.includes(pattern.domain)) {
-            patterns.push(pattern);
-          }
-        }
-
-        this.updateWorkflowProgress(
-          workflowId,
-          Math.round((patterns.length / 100) * 30)
-        );
-      }
-
-      // Export knowledge
-      const knowledgeResult = await this.transferService.queryKnowledge({
-        limit: 1000,
-      });
-      if (knowledgeResult.success) {
-        for (const item of knowledgeResult.value) {
-          if (targetDomains.includes(item.domain)) {
-            knowledge.push(item);
-          }
-        }
-      }
-
-      this.updateWorkflowProgress(workflowId, 60);
-
-      // Export strategies
-      const strategyKeys = await this.memory.search(
-        `learning:strategy:optimized:*`,
-        200
-      );
-      for (const key of strategyKeys) {
-        const strategy = await this.memory.get<OptimizedStrategy>(key);
-        if (strategy && targetDomains.includes(strategy.domain)) {
-          strategies.push(strategy);
-        }
-      }
-
-      this.updateWorkflowProgress(workflowId, 90);
-
-      // Calculate checksum
-      const checksum = this.calculateChecksum(patterns, knowledge, strategies);
-
-      this.completeWorkflow(workflowId);
-
-      const modelExport: ModelExport = {
-        version: '1.0.0',
-        exportedAt: new Date(),
-        patterns,
-        knowledge,
-        strategies,
-        checksum,
-      };
-
-      return ok(modelExport);
-    } catch (error) {
-      this.failWorkflow(workflowId, String(error));
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Import learned models
-   */
-  async importModels(modelExport: ModelExport): Promise<Result<ImportReport>> {
-    const workflowId = uuidv4();
-
-    try {
-      this.startWorkflow(workflowId, 'import');
-
-      // Validate checksum
-      const calculatedChecksum = this.calculateChecksum(
-        modelExport.patterns,
-        modelExport.knowledge,
-        modelExport.strategies
-      );
-
-      if (calculatedChecksum !== modelExport.checksum) {
-        this.failWorkflow(workflowId, 'Checksum mismatch');
-        return err(new Error('Import failed: checksum mismatch'));
-      }
-
-      let patternsImported = 0;
-      let knowledgeImported = 0;
-      let strategiesImported = 0;
-      const conflicts: ImportConflict[] = [];
-
-      // Import patterns
-      for (const pattern of modelExport.patterns) {
-        const existing = await this.memory.get<LearnedPattern>(
-          `learning:pattern:${pattern.id}`
-        );
-
-        if (existing) {
-          if (existing.confidence < pattern.confidence) {
-            // Overwrite with better pattern
-            await this.memory.set(`learning:pattern:${pattern.id}`, pattern, {
-              namespace: 'learning-optimization',
-              persist: true,
-            });
-            patternsImported++;
-            conflicts.push({
-              type: 'pattern',
-              id: pattern.id,
-              reason: 'Existing pattern had lower confidence',
-              resolution: 'overwrite',
-            });
-          } else {
-            conflicts.push({
-              type: 'pattern',
-              id: pattern.id,
-              reason: 'Existing pattern has higher confidence',
-              resolution: 'skip',
-            });
-          }
-        } else {
-          await this.memory.set(`learning:pattern:${pattern.id}`, pattern, {
-            namespace: 'learning-optimization',
-            persist: true,
-          });
-          patternsImported++;
-        }
-
-        this.updateWorkflowProgress(
-          workflowId,
-          Math.round((patternsImported / modelExport.patterns.length) * 30)
-        );
-      }
-
-      // Import knowledge
-      for (const item of modelExport.knowledge) {
-        const existing = await this.memory.get<Knowledge>(
-          `learning:knowledge:shared:${item.id}`
-        );
-
-        if (existing) {
-          if (item.version > existing.version) {
-            await this.memory.set(`learning:knowledge:shared:${item.id}`, item, {
-              namespace: 'learning-optimization',
-              persist: true,
-            });
-            knowledgeImported++;
-            conflicts.push({
-              type: 'knowledge',
-              id: item.id,
-              reason: 'Import has newer version',
-              resolution: 'overwrite',
-            });
-          } else {
-            conflicts.push({
-              type: 'knowledge',
-              id: item.id,
-              reason: 'Existing knowledge is same or newer version',
-              resolution: 'skip',
-            });
-          }
-        } else {
-          await this.memory.set(`learning:knowledge:shared:${item.id}`, item, {
-            namespace: 'learning-optimization',
-            persist: true,
-          });
-          knowledgeImported++;
-        }
-
-        this.updateWorkflowProgress(
-          workflowId,
-          30 + Math.round((knowledgeImported / modelExport.knowledge.length) * 30)
-        );
-      }
-
-      // Import strategies
-      for (const strategy of modelExport.strategies) {
-        const existing = await this.memory.get<OptimizedStrategy>(
-          `learning:strategy:optimized:${strategy.id}`
-        );
-
-        if (existing) {
-          if (strategy.confidence > existing.confidence) {
-            await this.memory.set(
-              `learning:strategy:optimized:${strategy.id}`,
-              strategy,
-              { namespace: 'learning-optimization', persist: true }
-            );
-            strategiesImported++;
-            conflicts.push({
-              type: 'strategy',
-              id: strategy.id,
-              reason: 'Import has higher confidence',
-              resolution: 'overwrite',
-            });
-          } else {
-            conflicts.push({
-              type: 'strategy',
-              id: strategy.id,
-              reason: 'Existing strategy has higher confidence',
-              resolution: 'skip',
-            });
-          }
-        } else {
-          await this.memory.set(
-            `learning:strategy:optimized:${strategy.id}`,
-            strategy,
-            { namespace: 'learning-optimization', persist: true }
-          );
-          strategiesImported++;
-        }
-
-        this.updateWorkflowProgress(
-          workflowId,
-          60 + Math.round((strategiesImported / modelExport.strategies.length) * 40)
-        );
-      }
-
-      this.completeWorkflow(workflowId);
-
-      const report: ImportReport = {
-        patternsImported,
-        knowledgeImported,
-        strategiesImported,
-        conflicts,
-        resolved: true,
-      };
-
-      return ok(report);
-    } catch (error) {
-      this.failWorkflow(workflowId, String(error));
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Event Handling
-  // ============================================================================
-
-  private subscribeToEvents(): void {
-    // Subscribe to test execution events for learning
-    this.eventBus.subscribe(
-      'test-execution.TestRunCompleted',
-      this.handleTestRunCompleted.bind(this)
-    );
-
-    // Subscribe to coverage gap events
-    this.eventBus.subscribe(
-      'coverage-analysis.CoverageGapDetected',
-      this.handleCoverageGap.bind(this)
-    );
-
-    // Subscribe to quality assessment events
-    this.eventBus.subscribe(
-      'quality-assessment.QualityGateEvaluated',
-      this.handleQualityGate.bind(this)
-    );
-  }
-
-  private async handleTestRunCompleted(event: {
-    payload: { runId: string; passed: number; failed: number; duration: number };
-  }): Promise<void> {
-    // Record experience from test run
-    const { runId, passed, failed, duration } = event.payload;
-    const successRate = (passed + failed) > 0 ? passed / (passed + failed) : 0;
-
-    await this.learningService.recordExperience({
-      agentId: {
-        value: 'test-execution',
-        domain: 'test-execution',
-        type: 'tester',
-      },
-      domain: 'test-execution',
-      action: 'test-run',
-      state: {
-        context: { runId },
-        metrics: { passed, failed, duration },
-      },
-      result: {
-        success: successRate > 0.8,
-        outcome: { success_rate: successRate, passed, failed },
-        duration,
-      },
-      reward: successRate,
-    });
-  }
-
-  private async handleCoverageGap(event: {
-    payload: { gapId: string; file: string; riskScore: number };
-  }): Promise<void> {
-    // Record as experience for learning
-    const { gapId, file, riskScore } = event.payload;
-
-    await this.learningService.recordExperience({
-      agentId: {
-        value: 'coverage-analysis',
-        domain: 'coverage-analysis',
-        type: 'analyzer',
-      },
-      domain: 'coverage-analysis',
-      action: 'gap-detection',
-      state: {
-        context: { gapId, file },
-        metrics: { riskScore },
-      },
-      result: {
-        success: true,
-        outcome: { risk_score: riskScore },
-        duration: 0,
-      },
-      reward: 1 - riskScore, // Lower risk = higher reward
-    });
-  }
-
-  private async handleQualityGate(event: {
-    payload: { gateId: string; passed: boolean };
-  }): Promise<void> {
-    const { gateId, passed } = event.payload;
-
-    await this.learningService.recordExperience({
-      agentId: {
-        value: 'quality-assessment',
-        domain: 'quality-assessment',
-        type: 'validator',
-      },
-      domain: 'quality-assessment',
-      action: 'gate-evaluation',
-      state: {
-        context: { gateId },
-        metrics: { passed: passed ? 1 : 0 },
-      },
-      result: {
-        success: passed,
-        outcome: { gate_passed: passed ? 1 : 0 },
-        duration: 0,
-      },
-      reward: passed ? 1 : 0,
-    });
-  }
-
-  // ============================================================================
-  // Event Publishing
-  // ============================================================================
-
-  private async publishPatternConsolidated(
-    patternCount: number,
-    domains: DomainName[]
-  ): Promise<void> {
-    const payload: PatternConsolidatedPayload = {
-      patternCount,
-      domains,
-      improvements: 0,
-    };
-
-    const event = createEvent(
-      LearningOptimizationEvents.PatternConsolidated,
-      'learning-optimization',
-      payload
-    );
-
-    await this.eventBus.publish(event);
-  }
-
-  private async publishTransferCompleted(
-    report: CrossDomainSharingReport
-  ): Promise<void> {
-    const payload: TransferCompletedPayload = {
-      sourceProject: 'current',
-      targetProject: 'current',
-      patternsTransferred: report.knowledgeShared,
-      successRate: report.transferSuccessRate,
-    };
-
-    const event = createEvent(
-      LearningOptimizationEvents.TransferCompleted,
-      'learning-optimization',
-      payload
-    );
-
-    await this.eventBus.publish(event);
-  }
-
-  private async publishOptimizationApplied(
-    report: OptimizationReport
-  ): Promise<void> {
-    const event = createEvent(
-      LearningOptimizationEvents.OptimizationApplied,
-      'learning-optimization',
-      {
-        domainsOptimized: report.domainsOptimized,
-        avgImprovement: report.avgImprovement,
-      }
-    );
-
-    await this.eventBus.publish(event);
-  }
-
-  // ============================================================================
-  // Agent Management
-  // ============================================================================
-
-  private async spawnLearningAgent(
-    workflowId: string,
-    domain: DomainName
-  ): Promise<Result<string, Error>> {
-    if (!this.agentCoordinator.canSpawn()) {
-      return err(new Error('Agent limit reached'));
-    }
-
-    const config: AgentSpawnConfig = {
-      name: `learning-agent-${workflowId.slice(0, 8)}`,
-      domain: 'learning-optimization',
-      type: 'optimizer',
-      capabilities: ['pattern-learning', 'experience-mining', domain],
-      config: {
-        workflowId,
-        targetDomain: domain,
-      },
-    };
-
-    return this.agentCoordinator.spawn(config);
-  }
-
-  // ============================================================================
-  // Workflow Management
-  // ============================================================================
-
-  private startWorkflow(
-    id: string,
-    type: LearningWorkflowStatus['type']
-  ): void {
-    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,
-    });
-  }
-
-  private completeWorkflow(id: string): void {
-    const workflow = this.workflows.get(id);
-    if (workflow) {
-      workflow.status = 'completed';
-      workflow.completedAt = new Date();
-      workflow.progress = 100;
-    }
-  }
-
-  private failWorkflow(id: string, error: string): void {
-    const workflow = this.workflows.get(id);
-    if (workflow) {
-      workflow.status = 'failed';
-      workflow.completedAt = new Date();
-      workflow.error = error;
-    }
-  }
-
-  private addAgentToWorkflow(workflowId: string, agentId: string): void {
-    const workflow = this.workflows.get(workflowId);
-    if (workflow) {
-      workflow.agentIds.push(agentId);
-    }
-  }
-
-  private updateWorkflowProgress(id: string, progress: number): void {
-    const workflow = this.workflows.get(id);
-    if (workflow) {
-      workflow.progress = Math.min(100, Math.max(0, progress));
-    }
-  }
-
-  // ============================================================================
-  // State Persistence
-  // ============================================================================
-
-  private async loadWorkflowState(): Promise<void> {
-    const savedState = await this.memory.get<LearningWorkflowStatus[]>(
-      'learning-optimization:coordinator:workflows'
-    );
-
-    if (savedState) {
-      for (const workflow of savedState) {
-        if (workflow.status === 'running') {
-          workflow.status = 'failed';
-          workflow.error = 'Coordinator restarted';
-          workflow.completedAt = new Date();
-        }
-        this.workflows.set(workflow.id, workflow);
-      }
-    }
-  }
-
-  private async saveWorkflowState(): Promise<void> {
-    const workflows = Array.from(this.workflows.values());
-    await this.memory.set(
-      'learning-optimization:coordinator:workflows',
-      workflows,
-      { namespace: 'learning-optimization', persist: true }
-    );
-  }
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  private async getExperiencesForDomain(
-    domain: DomainName,
-    timeRange: TimeRange
-  ): Promise<Result<Experience[]>> {
-    const keys = await this.memory.search(
-      `learning:experience:index:domain:${domain}:*`,
-      500
-    );
-    const experiences: Experience[] = [];
-
-    for (const key of keys) {
-      const experienceId = await this.memory.get<string>(key);
-      if (experienceId) {
-        const experience = await this.memory.get<Experience>(
-          `learning:experience:${experienceId}`
-        );
-        if (experience && timeRange.contains(experience.timestamp)) {
-          experiences.push(experience);
-        }
-      }
-    }
-
-    return ok(experiences);
-  }
-
-  private async getCurrentStrategy(domain: DomainName): Promise<{
-    name: string;
-    parameters: Record<string, unknown>;
-    expectedOutcome: Record<string, number>;
-  }> {
-    const strategyKey = `learning:strategy:current:${domain}`;
-    const existing = await this.memory.get<{
-      name: string;
-      parameters: Record<string, unknown>;
-      expectedOutcome: Record<string, number>;
-    }>(strategyKey);
-
-    if (existing) {
-      return existing;
-    }
-
-    // Return default strategy
-    return {
-      name: `default-${domain}`,
-      parameters: {
-        timeout: 30000,
-        retryCount: 3,
-        concurrency: 4,
-      },
-      expectedOutcome: {
-        success_rate: 0.8,
-      },
-    };
-  }
-
-  private async storeStrategy(
-    domain: DomainName,
-    strategy: { name: string; parameters: Record<string, unknown>; expectedOutcome: Record<string, number> }
-  ): Promise<void> {
-    await this.memory.set(`learning:strategy:current:${domain}`, strategy, {
-      namespace: 'learning-optimization',
-      persist: true,
-    });
-  }
-
-  private calculateMetricValue(
-    experiences: Experience[],
-    metric: string
-  ): number {
-    const values = experiences
-      .map((e) => (e.result.outcome[metric] as number) ?? 0)
-      .filter((v) => !isNaN(v));
-
-    if (values.length === 0) return 0;
-    return values.reduce((a, b) => a + b, 0) / values.length;
-  }
-
-  private getRelatedDomains(domain: DomainName): DomainName[] {
-    const relationships: Record<DomainName, DomainName[]> = {
-      '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'),
-    };
-
-    return relationships[domain] || [];
-  }
-
-  private findSimilarPatterns(patterns: LearnedPattern[]): LearnedPattern[][] {
-    const groups: LearnedPattern[][] = [];
-    const assigned = new Set<string>();
-
-    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;
-  }
-
-  private contextsOverlap(
-    a: { tags: string[] },
-    b: { tags: string[] }
-  ): boolean {
-    return a.tags.some((tag) => b.tags.includes(tag));
-  }
-
-  private calculateChecksum(
-    patterns: LearnedPattern[],
-    knowledge: Knowledge[],
-    strategies: OptimizedStrategy[]
-  ): string {
-    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);
-  }
-}