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

package/src/coordination/protocols/learning-consolidation.ts

@@ -1,1181 +0,0 @@
-/**
- * Agentic QE v3 - Learning Consolidation Protocol
- *
- * Schedule: Friday 6pm (weekly)
- * Participants: Learning Coordinator, Transfer Specialist, Pattern Learner
- * Actions: Gather patterns, consolidate, update knowledge base
- */
-
-import { v4 as uuidv4 } from 'uuid';
-import {
-  Result,
-  ok,
-  err,
-  DomainName,
-  ALL_DOMAINS,
-  DomainEvent,
-} from '../../shared/types/index.js';
-import { TimeRange } from '../../shared/value-objects/index.js';
-import { EventBus, MemoryBackend } from '../../kernel/interfaces.js';
-import {
-  LearnedPattern,
-  PatternType,
-  Knowledge,
-  IPatternLearningService,
-  IKnowledgeSynthesisService,
-} from '../../domains/learning-optimization/interfaces.js';
-
-// ============================================================================
-// Protocol Configuration
-// ============================================================================
-
-export interface LearningConsolidationConfig {
-  /** Minimum patterns per domain to trigger consolidation */
-  minPatternsForConsolidation: number;
-  /** Pattern similarity threshold for merging (0-1) */
-  similarityThreshold: number;
-  /** Maximum patterns to keep per domain after consolidation */
-  maxPatternsPerDomain: number;
-  /** Minimum confidence to retain pattern */
-  minConfidenceThreshold: number;
-  /** Number of weeks of data to analyze */
-  analysisWindowWeeks: number;
-  /** Enable cross-project transfer */
-  enableCrossProjectTransfer: boolean;
-}
-
-const DEFAULT_CONFIG: LearningConsolidationConfig = {
-  minPatternsForConsolidation: 5,
-  similarityThreshold: 0.85,
-  maxPatternsPerDomain: 100,
-  minConfidenceThreshold: 0.5,
-  analysisWindowWeeks: 4,
-  enableCrossProjectTransfer: true,
-};
-
-// ============================================================================
-// Protocol Events
-// ============================================================================
-
-export interface LearningConsolidationStartedEvent extends DomainEvent {
-  readonly type: 'LearningConsolidationStarted';
-  readonly payload: {
-    consolidationId: string;
-    timestamp: Date;
-    domainsToProcess: DomainName[];
-  };
-}
-
-export interface PatternConsolidatedEvent extends DomainEvent {
-  readonly type: 'PatternConsolidated';
-  readonly payload: {
-    consolidationId: string;
-    domain: DomainName;
-    patternsBeforeCount: number;
-    patternsAfterCount: number;
-    mergedPatternIds: string[];
-    removedPatternIds: string[];
-  };
-}
-
-export interface LearningConsolidationCompletedEvent extends DomainEvent {
-  readonly type: 'LearningConsolidationCompleted';
-  readonly payload: {
-    consolidationId: string;
-    stats: ConsolidationStats;
-    insights: WeeklyInsight[];
-    duration: number;
-  };
-}
-
-export interface TransferReadyEvent extends DomainEvent {
-  readonly type: 'TransferReady';
-  readonly payload: {
-    consolidationId: string;
-    transferablePatterns: TransferablePattern[];
-    targetProjects: string[];
-  };
-}
-
-// ============================================================================
-// Protocol Data Types
-// ============================================================================
-
-export interface DomainPatternGroup {
-  domain: DomainName;
-  patterns: LearnedPattern[];
-  stats: DomainPatternStats;
-}
-
-export interface DomainPatternStats {
-  totalPatterns: number;
-  avgConfidence: number;
-  avgSuccessRate: number;
-  avgUsageCount: number;
-  topPatternType: PatternType;
-  newPatternsThisWeek: number;
-}
-
-export interface ConsolidationStats {
-  domainsProcessed: number;
-  totalPatternsAnalyzed: number;
-  patternsMerged: number;
-  patternsRemoved: number;
-  patternsRetained: number;
-  knowledgeItemsUpdated: number;
-  improvementOpportunities: number;
-  crossDomainTransfers: number;
-}
-
-export interface WeeklyInsight {
-  type: 'improvement' | 'trend' | 'anomaly' | 'recommendation';
-  domain: DomainName;
-  title: string;
-  description: string;
-  impact: 'high' | 'medium' | 'low';
-  actionItems: string[];
-}
-
-export interface TransferablePattern {
-  patternId: string;
-  domain: DomainName;
-  name: string;
-  applicableDomains: DomainName[];
-  transferConfidence: number;
-  reason: string;
-}
-
-export interface ConsolidationResult {
-  consolidationId: string;
-  startedAt: Date;
-  completedAt: Date;
-  stats: ConsolidationStats;
-  insights: WeeklyInsight[];
-  transferablePatterns: TransferablePattern[];
-  domainReports: DomainConsolidationReport[];
-}
-
-export interface DomainConsolidationReport {
-  domain: DomainName;
-  patternsBeforeCount: number;
-  patternsAfterCount: number;
-  mergedPatterns: MergedPatternInfo[];
-  removedPatterns: RemovedPatternInfo[];
-  topPerformingPatterns: LearnedPattern[];
-  improvementAreas: string[];
-}
-
-export interface MergedPatternInfo {
-  resultPatternId: string;
-  sourcePatternIds: string[];
-  mergeReason: string;
-}
-
-export interface RemovedPatternInfo {
-  patternId: string;
-  name: string;
-  removalReason: string;
-}
-
-// ============================================================================
-// Learning Consolidation Protocol Implementation
-// ============================================================================
-
-/**
- * Learning Consolidation Protocol
- *
- * Orchestrates weekly learning consolidation across all QE domains.
- * Gathers patterns, consolidates similar ones, removes underperformers,
- * and prepares high-value patterns for cross-project transfer.
- */
-export class LearningConsolidationProtocol {
-  private readonly config: LearningConsolidationConfig;
-
-  constructor(
-    private readonly eventBus: EventBus,
-    private readonly memory: MemoryBackend,
-    private readonly patternService: IPatternLearningService,
-    private readonly knowledgeService: IKnowledgeSynthesisService,
-    config: Partial<LearningConsolidationConfig> = {}
-  ) {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-
-  // ============================================================================
-  // Main Execution
-  // ============================================================================
-
-  /**
-   * Execute the weekly learning consolidation protocol
-   */
-  async execute(): Promise<Result<ConsolidationResult>> {
-    const consolidationId = uuidv4();
-    const startedAt = new Date();
-
-    try {
-      // Publish start event
-      await this.publishStartEvent(consolidationId);
-
-      // Step 1: Gather patterns from all domains
-      const gatheredPatterns = await this.gatherPatterns();
-      if (!gatheredPatterns.success) {
-        return err(gatheredPatterns.error);
-      }
-
-      // Step 2: Consolidate patterns per domain
-      const domainReports: DomainConsolidationReport[] = [];
-      let totalMerged = 0;
-      let totalRemoved = 0;
-      let totalRetained = 0;
-
-      for (const domainGroup of gatheredPatterns.value) {
-        const consolidationResult = await this.consolidatePatterns(
-          consolidationId,
-          domainGroup
-        );
-        if (consolidationResult.success) {
-          domainReports.push(consolidationResult.value);
-          totalMerged += consolidationResult.value.mergedPatterns.length;
-          totalRemoved += consolidationResult.value.removedPatterns.length;
-          totalRetained += consolidationResult.value.patternsAfterCount;
-        }
-      }
-
-      // Step 3: Update knowledge base with consolidated patterns
-      const knowledgeUpdateResult = await this.updateKnowledgeBase(domainReports);
-
-      // Step 4: Prepare patterns for cross-project transfer
-      const transferResult = await this.prepareTransfer(
-        consolidationId,
-        domainReports
-      );
-
-      // Step 5: Generate weekly insights
-      const insights = await this.generateInsights(
-        gatheredPatterns.value,
-        domainReports
-      );
-
-      const completedAt = new Date();
-      const duration = completedAt.getTime() - startedAt.getTime();
-
-      const stats: ConsolidationStats = {
-        domainsProcessed: domainReports.length,
-        totalPatternsAnalyzed: gatheredPatterns.value.reduce(
-          (sum, g) => sum + g.patterns.length,
-          0
-        ),
-        patternsMerged: totalMerged,
-        patternsRemoved: totalRemoved,
-        patternsRetained: totalRetained,
-        knowledgeItemsUpdated: knowledgeUpdateResult.success
-          ? knowledgeUpdateResult.value
-          : 0,
-        improvementOpportunities: insights.filter(
-          (i) => i.type === 'improvement'
-        ).length,
-        crossDomainTransfers: transferResult.success
-          ? transferResult.value.length
-          : 0,
-      };
-
-      // Publish completion event
-      await this.publishCompletedEvent(consolidationId, stats, insights, duration);
-
-      const result: ConsolidationResult = {
-        consolidationId,
-        startedAt,
-        completedAt,
-        stats,
-        insights,
-        transferablePatterns: transferResult.success ? transferResult.value : [],
-        domainReports,
-      };
-
-      // Store result for historical analysis
-      await this.storeConsolidationResult(result);
-
-      return ok(result);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  // ============================================================================
-  // Pattern Gathering
-  // ============================================================================
-
-  /**
-   * Gather patterns from all 12 domains
-   */
-  async gatherPatterns(): Promise<Result<DomainPatternGroup[]>> {
-    try {
-      const domainGroups: DomainPatternGroup[] = [];
-      const timeRange = TimeRange.lastNDays(this.config.analysisWindowWeeks * 7);
-
-      for (const domain of ALL_DOMAINS) {
-        const patterns = await this.getPatternsForDomain(domain, timeRange);
-        if (patterns.length > 0) {
-          const stats = this.calculateDomainStats(patterns, timeRange);
-          domainGroups.push({ domain, patterns, stats });
-        }
-      }
-
-      return ok(domainGroups);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Get patterns for a specific domain
-   */
-  private async getPatternsForDomain(
-    domain: DomainName,
-    timeRange: TimeRange
-  ): Promise<LearnedPattern[]> {
-    const keys = await this.memory.search(`learning:pattern:*`, 500);
-    const patterns: LearnedPattern[] = [];
-
-    for (const key of keys) {
-      const pattern = await this.memory.get<LearnedPattern>(key);
-      if (
-        pattern &&
-        pattern.domain === domain &&
-        !key.includes(':archived:') &&
-        (timeRange.contains(pattern.createdAt) || timeRange.contains(pattern.lastUsedAt))
-      ) {
-        patterns.push(pattern);
-      }
-    }
-
-    return patterns;
-  }
-
-  /**
-   * Calculate statistics for a domain's patterns
-   */
-  private calculateDomainStats(
-    patterns: LearnedPattern[],
-    timeRange: TimeRange
-  ): DomainPatternStats {
-    if (patterns.length === 0) {
-      return {
-        totalPatterns: 0,
-        avgConfidence: 0,
-        avgSuccessRate: 0,
-        avgUsageCount: 0,
-        topPatternType: 'workflow-pattern',
-        newPatternsThisWeek: 0,
-      };
-    }
-
-    const typeCounts: Map<PatternType, number> = new Map();
-    let totalConfidence = 0;
-    let totalSuccessRate = 0;
-    let totalUsageCount = 0;
-    let newPatterns = 0;
-
-    for (const pattern of patterns) {
-      totalConfidence += pattern.confidence;
-      totalSuccessRate += pattern.successRate;
-      totalUsageCount += pattern.usageCount;
-      typeCounts.set(pattern.type, (typeCounts.get(pattern.type) || 0) + 1);
-
-      if (timeRange.contains(pattern.createdAt)) {
-        newPatterns++;
-      }
-    }
-
-    let topType: PatternType = 'workflow-pattern';
-    let maxCount = 0;
-    for (const [type, count] of typeCounts) {
-      if (count > maxCount) {
-        maxCount = count;
-        topType = type;
-      }
-    }
-
-    return {
-      totalPatterns: patterns.length,
-      avgConfidence: totalConfidence / patterns.length,
-      avgSuccessRate: totalSuccessRate / patterns.length,
-      avgUsageCount: totalUsageCount / patterns.length,
-      topPatternType: topType,
-      newPatternsThisWeek: newPatterns,
-    };
-  }
-
-  // ============================================================================
-  // Pattern Consolidation
-  // ============================================================================
-
-  /**
-   * Consolidate patterns within a domain - merge similar, remove underperformers
-   */
-  async consolidatePatterns(
-    consolidationId: string,
-    domainGroup: DomainPatternGroup
-  ): Promise<Result<DomainConsolidationReport>> {
-    try {
-      const { domain, patterns } = domainGroup;
-      const mergedPatterns: MergedPatternInfo[] = [];
-      const removedPatterns: RemovedPatternInfo[] = [];
-      const retainedPatterns: LearnedPattern[] = [];
-
-      // Group similar patterns for merging
-      const similarGroups = this.groupSimilarPatterns(patterns);
-
-      for (const group of similarGroups) {
-        if (group.length >= 2) {
-          // Merge similar patterns
-          const mergeResult = await this.mergePatternGroup(group);
-          if (mergeResult.success) {
-            mergedPatterns.push({
-              resultPatternId: mergeResult.value.id,
-              sourcePatternIds: group.map((p) => p.id),
-              mergeReason: 'Similar pattern context and template',
-            });
-            retainedPatterns.push(mergeResult.value);
-          }
-        } else {
-          // Single pattern - check if it should be retained
-          const pattern = group[0];
-          if (this.shouldRetainPattern(pattern)) {
-            retainedPatterns.push(pattern);
-          } else {
-            removedPatterns.push({
-              patternId: pattern.id,
-              name: pattern.name,
-              removalReason: this.getRemovalReason(pattern),
-            });
-            await this.archivePattern(pattern);
-          }
-        }
-      }
-
-      // Trim to max patterns if needed
-      const finalPatterns = this.trimToMaxPatterns(retainedPatterns, domain);
-      const trimmedCount = retainedPatterns.length - finalPatterns.length;
-      if (trimmedCount > 0) {
-        const trimmed = retainedPatterns.slice(finalPatterns.length);
-        for (const p of trimmed) {
-          removedPatterns.push({
-            patternId: p.id,
-            name: p.name,
-            removalReason: 'Exceeded max patterns per domain limit',
-          });
-          await this.archivePattern(p);
-        }
-      }
-
-      // Publish domain consolidation event
-      await this.publishPatternConsolidatedEvent(
-        consolidationId,
-        domain,
-        patterns.length,
-        finalPatterns.length,
-        mergedPatterns.map((m) => m.resultPatternId),
-        removedPatterns.map((r) => r.patternId)
-      );
-
-      const report: DomainConsolidationReport = {
-        domain,
-        patternsBeforeCount: patterns.length,
-        patternsAfterCount: finalPatterns.length,
-        mergedPatterns,
-        removedPatterns,
-        topPerformingPatterns: this.getTopPerformingPatterns(finalPatterns, 5),
-        improvementAreas: this.identifyImprovementAreas(domainGroup),
-      };
-
-      return ok(report);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Group patterns by similarity
-   */
-  private groupSimilarPatterns(patterns: LearnedPattern[]): LearnedPattern[][] {
-    const groups: LearnedPattern[][] = [];
-    const assigned = new Set<string>();
-
-    for (const pattern of patterns) {
-      if (assigned.has(pattern.id)) continue;
-
-      const group: LearnedPattern[] = [pattern];
-      assigned.add(pattern.id);
-
-      for (const other of patterns) {
-        if (assigned.has(other.id)) continue;
-
-        if (this.areSimilarPatterns(pattern, other)) {
-          group.push(other);
-          assigned.add(other.id);
-        }
-      }
-
-      groups.push(group);
-    }
-
-    return groups;
-  }
-
-  /**
-   * Check if two patterns are similar enough to merge
-   */
-  private areSimilarPatterns(a: LearnedPattern, b: LearnedPattern): boolean {
-    // Same type required
-    if (a.type !== b.type) return false;
-
-    // Check context similarity
-    const contextSimilarity = this.calculateContextSimilarity(a.context, b.context);
-    if (contextSimilarity < this.config.similarityThreshold) return false;
-
-    // Check template type
-    if (a.template.type !== b.template.type) return false;
-
-    return true;
-  }
-
-  /**
-   * Calculate similarity between two pattern contexts
-   */
-  private calculateContextSimilarity(
-    a: { language?: string; framework?: string; testType?: string; tags: string[] },
-    b: { language?: string; framework?: string; testType?: string; tags: string[] }
-  ): number {
-    let score = 0;
-    let factors = 0;
-
-    // Language match
-    if (a.language && b.language) {
-      factors++;
-      if (a.language === b.language) score++;
-    }
-
-    // Framework match
-    if (a.framework && b.framework) {
-      factors++;
-      if (a.framework === b.framework) score++;
-    }
-
-    // Test type match
-    if (a.testType && b.testType) {
-      factors++;
-      if (a.testType === b.testType) score++;
-    }
-
-    // Tag overlap
-    if (a.tags.length > 0 && b.tags.length > 0) {
-      factors++;
-      const overlap = a.tags.filter((t) => b.tags.includes(t)).length;
-      const union = new Set([...a.tags, ...b.tags]).size;
-      score += overlap / union;
-    }
-
-    return factors > 0 ? score / factors : 0;
-  }
-
-  /**
-   * Merge a group of similar patterns into one
-   */
-  private async mergePatternGroup(
-    group: LearnedPattern[]
-  ): Promise<Result<LearnedPattern>> {
-    const patternIds = group.map((p) => p.id);
-    return this.patternService.consolidatePatterns(patternIds);
-  }
-
-  /**
-   * Check if a pattern should be retained
-   */
-  private shouldRetainPattern(pattern: LearnedPattern): boolean {
-    // Remove low confidence patterns
-    if (pattern.confidence < this.config.minConfidenceThreshold) {
-      return false;
-    }
-
-    // Remove patterns with poor success rate and low usage
-    if (pattern.successRate < 0.3 && pattern.usageCount < 5) {
-      return false;
-    }
-
-    // Check for staleness (not used in 30 days)
-    const daysSinceLastUse =
-      (Date.now() - pattern.lastUsedAt.getTime()) / (1000 * 60 * 60 * 24);
-    if (daysSinceLastUse > 30 && pattern.usageCount < 10) {
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Get reason for pattern removal
-   */
-  private getRemovalReason(pattern: LearnedPattern): string {
-    if (pattern.confidence < this.config.minConfidenceThreshold) {
-      return `Low confidence (${(pattern.confidence * 100).toFixed(1)}%)`;
-    }
-    if (pattern.successRate < 0.3) {
-      return `Low success rate (${(pattern.successRate * 100).toFixed(1)}%)`;
-    }
-    const daysSinceLastUse =
-      (Date.now() - pattern.lastUsedAt.getTime()) / (1000 * 60 * 60 * 24);
-    if (daysSinceLastUse > 30) {
-      return `Stale - not used in ${Math.round(daysSinceLastUse)} days`;
-    }
-    return 'Below retention threshold';
-  }
-
-  /**
-   * Archive a pattern (soft delete)
-   */
-  private async archivePattern(pattern: LearnedPattern): Promise<void> {
-    // Move to archived namespace
-    await this.memory.set(`learning:pattern:archived:${pattern.id}`, {
-      ...pattern,
-      archivedAt: new Date(),
-    }, { namespace: 'learning-optimization', persist: true });
-
-    // Delete from active patterns
-    await this.memory.delete(`learning:pattern:${pattern.id}`);
-  }
-
-  /**
-   * Trim patterns to max allowed per domain
-   */
-  private trimToMaxPatterns(
-    patterns: LearnedPattern[],
-    _domain: DomainName
-  ): LearnedPattern[] {
-    if (patterns.length <= this.config.maxPatternsPerDomain) {
-      return patterns;
-    }
-
-    // Sort by effectiveness score and keep top N
-    return patterns
-      .sort((a, b) => {
-        const scoreA = a.confidence * 0.4 + a.successRate * 0.4 + Math.min(a.usageCount / 100, 0.2);
-        const scoreB = b.confidence * 0.4 + b.successRate * 0.4 + Math.min(b.usageCount / 100, 0.2);
-        return scoreB - scoreA;
-      })
-      .slice(0, this.config.maxPatternsPerDomain);
-  }
-
-  /**
-   * Get top performing patterns
-   */
-  private getTopPerformingPatterns(
-    patterns: LearnedPattern[],
-    count: number
-  ): LearnedPattern[] {
-    return patterns
-      .sort((a, b) => {
-        const scoreA = a.successRate * 0.6 + a.confidence * 0.4;
-        const scoreB = b.successRate * 0.6 + b.confidence * 0.4;
-        return scoreB - scoreA;
-      })
-      .slice(0, count);
-  }
-
-  /**
-   * Identify improvement areas for a domain
-   */
-  private identifyImprovementAreas(group: DomainPatternGroup): string[] {
-    const areas: string[] = [];
-    const { stats } = group;
-
-    if (stats.avgSuccessRate < 0.7) {
-      areas.push(`Improve pattern success rate (currently ${(stats.avgSuccessRate * 100).toFixed(1)}%)`);
-    }
-
-    if (stats.avgConfidence < 0.6) {
-      areas.push(`Increase pattern confidence through more training data`);
-    }
-
-    if (stats.newPatternsThisWeek === 0) {
-      areas.push(`No new patterns learned this week - consider gathering more experiences`);
-    }
-
-    if (stats.avgUsageCount < 5) {
-      areas.push(`Low pattern utilization - promote pattern adoption`);
-    }
-
-    return areas;
-  }
-
-  // ============================================================================
-  // Knowledge Base Update
-  // ============================================================================
-
-  /**
-   * Update knowledge base with consolidated patterns
-   */
-  async updateKnowledgeBase(
-    domainReports: DomainConsolidationReport[]
-  ): Promise<Result<number>> {
-    try {
-      let updatedCount = 0;
-
-      for (const report of domainReports) {
-        // Create knowledge entries for top performing patterns
-        for (const pattern of report.topPerformingPatterns) {
-          const knowledgeResult = await this.createKnowledgeFromPattern(pattern);
-          if (knowledgeResult.success) {
-            updatedCount++;
-
-            // Share high-performing pattern knowledge with related domains
-            if (pattern.successRate >= 0.8) {
-              const knowledge = await this.memory.get<Knowledge>(
-                `learning:knowledge:pattern:${pattern.id}`
-              );
-              if (knowledge) {
-                // Use knowledgeService to share across domains
-                await this.knowledgeService.shareKnowledge(knowledge, [
-                  {
-                    value: `${pattern.domain}-coordinator`,
-                    domain: pattern.domain,
-                    type: 'coordinator',
-                  },
-                ]);
-              }
-            }
-          }
-        }
-
-        // Store consolidation summary as knowledge
-        await this.storeConsolidationSummary(report);
-        updatedCount++;
-      }
-
-      return ok(updatedCount);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Create a knowledge entry from a high-performing pattern
-   */
-  private async createKnowledgeFromPattern(
-    pattern: LearnedPattern
-  ): Promise<Result<void>> {
-    const knowledge: Knowledge = {
-      id: uuidv4(),
-      type: 'heuristic',
-      domain: pattern.domain,
-      content: {
-        format: 'json',
-        data: {
-          patternId: pattern.id,
-          patternType: pattern.type,
-          template: pattern.template,
-          context: pattern.context,
-          effectiveness: {
-            confidence: pattern.confidence,
-            successRate: pattern.successRate,
-            usageCount: pattern.usageCount,
-          },
-        },
-        metadata: {
-          sourceType: 'pattern-consolidation',
-          consolidatedAt: new Date().toISOString(),
-        },
-      },
-      sourceAgentId: {
-        value: 'learning-consolidation-protocol',
-        domain: 'learning-optimization',
-        type: 'coordinator',
-      },
-      targetDomains: [pattern.domain],
-      relevanceScore: pattern.confidence * 0.5 + pattern.successRate * 0.5,
-      version: 1,
-      createdAt: new Date(),
-    };
-
-    await this.memory.set(`learning:knowledge:pattern:${pattern.id}`, knowledge, {
-      namespace: 'learning-optimization',
-      persist: true,
-    });
-
-    return ok(undefined);
-  }
-
-  /**
-   * Store consolidation summary as knowledge
-   */
-  private async storeConsolidationSummary(
-    report: DomainConsolidationReport
-  ): Promise<void> {
-    await this.memory.set(
-      `learning:consolidation:summary:${report.domain}:${Date.now()}`,
-      {
-        domain: report.domain,
-        date: new Date(),
-        patternsBefore: report.patternsBeforeCount,
-        patternsAfter: report.patternsAfterCount,
-        mergedCount: report.mergedPatterns.length,
-        removedCount: report.removedPatterns.length,
-        improvementAreas: report.improvementAreas,
-      },
-      { namespace: 'learning-optimization', persist: true }
-    );
-  }
-
-  // ============================================================================
-  // Cross-Project Transfer
-  // ============================================================================
-
-  /**
-   * Prepare high-value patterns for cross-project transfer
-   */
-  async prepareTransfer(
-    consolidationId: string,
-    domainReports: DomainConsolidationReport[]
-  ): Promise<Result<TransferablePattern[]>> {
-    try {
-      if (!this.config.enableCrossProjectTransfer) {
-        return ok([]);
-      }
-
-      const transferablePatterns: TransferablePattern[] = [];
-
-      for (const report of domainReports) {
-        for (const pattern of report.topPerformingPatterns) {
-          // Only transfer highly effective patterns
-          if (pattern.successRate >= 0.8 && pattern.confidence >= 0.7) {
-            const applicableDomains = this.findApplicableDomains(pattern);
-            if (applicableDomains.length > 1) {
-              transferablePatterns.push({
-                patternId: pattern.id,
-                domain: pattern.domain,
-                name: pattern.name,
-                applicableDomains,
-                transferConfidence: Math.min(pattern.successRate, pattern.confidence),
-                reason: `High success rate (${(pattern.successRate * 100).toFixed(0)}%) with ${pattern.usageCount} uses`,
-              });
-            }
-          }
-        }
-      }
-
-      // Publish transfer ready event if we have patterns to transfer
-      if (transferablePatterns.length > 0) {
-        await this.publishTransferReadyEvent(consolidationId, transferablePatterns);
-      }
-
-      return ok(transferablePatterns);
-    } catch (error) {
-      return err(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-
-  /**
-   * Find domains where a pattern could be applicable
-   */
-  private findApplicableDomains(pattern: LearnedPattern): DomainName[] {
-    const relatedDomains: 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 [pattern.domain, ...(relatedDomains[pattern.domain] || [])];
-  }
-
-  // ============================================================================
-  // Insight Generation
-  // ============================================================================
-
-  /**
-   * Generate weekly learning report with insights
-   */
-  async generateInsights(
-    gatheredPatterns: DomainPatternGroup[],
-    domainReports: DomainConsolidationReport[]
-  ): Promise<WeeklyInsight[]> {
-    const insights: WeeklyInsight[] = [];
-
-    // Analyze each domain
-    for (const group of gatheredPatterns) {
-      const report = domainReports.find((r) => r.domain === group.domain);
-
-      // Check for significant pattern growth
-      if (group.stats.newPatternsThisWeek > 5) {
-        insights.push({
-          type: 'trend',
-          domain: group.domain,
-          title: `High pattern learning activity in ${group.domain}`,
-          description: `${group.stats.newPatternsThisWeek} new patterns learned this week`,
-          impact: 'medium',
-          actionItems: ['Review new patterns for quality', 'Monitor success rates'],
-        });
-      }
-
-      // Check for declining success rates
-      if (group.stats.avgSuccessRate < 0.5) {
-        insights.push({
-          type: 'anomaly',
-          domain: group.domain,
-          title: `Low average success rate in ${group.domain}`,
-          description: `Average success rate is ${(group.stats.avgSuccessRate * 100).toFixed(1)}%`,
-          impact: 'high',
-          actionItems: [
-            'Review pattern selection criteria',
-            'Gather more training experiences',
-            'Consider retiring low-performing patterns',
-          ],
-        });
-      }
-
-      // Identify improvement opportunities
-      if (report && report.improvementAreas.length > 0) {
-        insights.push({
-          type: 'improvement',
-          domain: group.domain,
-          title: `Improvement opportunities in ${group.domain}`,
-          description: `${report.improvementAreas.length} areas identified for improvement`,
-          impact: 'medium',
-          actionItems: report.improvementAreas,
-        });
-      }
-
-      // Recommend consolidation if many patterns
-      if (group.patterns.length > this.config.maxPatternsPerDomain * 0.8) {
-        insights.push({
-          type: 'recommendation',
-          domain: group.domain,
-          title: `Pattern count nearing limit in ${group.domain}`,
-          description: `${group.patterns.length} patterns (limit: ${this.config.maxPatternsPerDomain})`,
-          impact: 'low',
-          actionItems: [
-            'Review pattern effectiveness',
-            'Consider more aggressive consolidation',
-          ],
-        });
-      }
-    }
-
-    // Cross-domain insights
-    const topDomains = gatheredPatterns
-      .sort((a, b) => b.stats.avgSuccessRate - a.stats.avgSuccessRate)
-      .slice(0, 3);
-
-    if (topDomains.length > 0) {
-      insights.push({
-        type: 'trend',
-        domain: topDomains[0].domain,
-        title: 'Top performing domains',
-        description: `Best success rates: ${topDomains.map((d) => `${d.domain} (${(d.stats.avgSuccessRate * 100).toFixed(0)}%)`).join(', ')}`,
-        impact: 'medium',
-        actionItems: ['Analyze successful patterns for cross-domain application'],
-      });
-    }
-
-    return insights;
-  }
-
-  // ============================================================================
-  // Event Publishing
-  // ============================================================================
-
-  private async publishStartEvent(consolidationId: string): Promise<void> {
-    const event: LearningConsolidationStartedEvent = {
-      id: uuidv4(),
-      type: 'LearningConsolidationStarted',
-      timestamp: new Date(),
-      source: 'learning-optimization',
-      payload: {
-        consolidationId,
-        timestamp: new Date(),
-        domainsToProcess: [...ALL_DOMAINS],
-      },
-    };
-    await this.eventBus.publish(event);
-  }
-
-  private async publishPatternConsolidatedEvent(
-    consolidationId: string,
-    domain: DomainName,
-    patternsBeforeCount: number,
-    patternsAfterCount: number,
-    mergedPatternIds: string[],
-    removedPatternIds: string[]
-  ): Promise<void> {
-    const event: PatternConsolidatedEvent = {
-      id: uuidv4(),
-      type: 'PatternConsolidated',
-      timestamp: new Date(),
-      source: 'learning-optimization',
-      payload: {
-        consolidationId,
-        domain,
-        patternsBeforeCount,
-        patternsAfterCount,
-        mergedPatternIds,
-        removedPatternIds,
-      },
-    };
-    await this.eventBus.publish(event);
-  }
-
-  private async publishCompletedEvent(
-    consolidationId: string,
-    stats: ConsolidationStats,
-    insights: WeeklyInsight[],
-    duration: number
-  ): Promise<void> {
-    const event: LearningConsolidationCompletedEvent = {
-      id: uuidv4(),
-      type: 'LearningConsolidationCompleted',
-      timestamp: new Date(),
-      source: 'learning-optimization',
-      payload: {
-        consolidationId,
-        stats,
-        insights,
-        duration,
-      },
-    };
-    await this.eventBus.publish(event);
-  }
-
-  private async publishTransferReadyEvent(
-    consolidationId: string,
-    transferablePatterns: TransferablePattern[]
-  ): Promise<void> {
-    // Extract unique target projects (in this case, we derive from domains)
-    const targetProjects = [...new Set(
-      transferablePatterns.flatMap((p) => p.applicableDomains)
-    )].map((d) => `project-${d}`);
-
-    const event: TransferReadyEvent = {
-      id: uuidv4(),
-      type: 'TransferReady',
-      timestamp: new Date(),
-      source: 'learning-optimization',
-      payload: {
-        consolidationId,
-        transferablePatterns,
-        targetProjects,
-      },
-    };
-    await this.eventBus.publish(event);
-  }
-
-  // ============================================================================
-  // Storage
-  // ============================================================================
-
-  private async storeConsolidationResult(result: ConsolidationResult): Promise<void> {
-    await this.memory.set(
-      `learning:consolidation:result:${result.consolidationId}`,
-      result,
-      { namespace: 'learning-optimization', persist: true }
-    );
-
-    // Also store in historical timeline
-    await this.memory.set(
-      `learning:consolidation:history:${result.completedAt.getTime()}`,
-      {
-        consolidationId: result.consolidationId,
-        completedAt: result.completedAt,
-        stats: result.stats,
-      },
-      { namespace: 'learning-optimization', persist: true }
-    );
-  }
-
-  // ============================================================================
-  // Utility Methods
-  // ============================================================================
-
-  /**
-   * Get previous consolidation results for trend analysis
-   */
-  async getPreviousConsolidations(count: number): Promise<ConsolidationResult[]> {
-    const keys = await this.memory.search('learning:consolidation:result:*', count);
-    const results: ConsolidationResult[] = [];
-
-    for (const key of keys) {
-      const result = await this.memory.get<ConsolidationResult>(key);
-      if (result) {
-        results.push(result);
-      }
-    }
-
-    return results.sort(
-      (a, b) => b.completedAt.getTime() - a.completedAt.getTime()
-    );
-  }
-
-  /**
-   * Get consolidation history summary
-   */
-  async getConsolidationHistory(weeks: number): Promise<{
-    consolidations: number;
-    totalPatternsMerged: number;
-    totalPatternsRemoved: number;
-    avgImprovementOpportunities: number;
-  }> {
-    const results = await this.getPreviousConsolidations(weeks);
-
-    if (results.length === 0) {
-      return {
-        consolidations: 0,
-        totalPatternsMerged: 0,
-        totalPatternsRemoved: 0,
-        avgImprovementOpportunities: 0,
-      };
-    }
-
-    const totalMerged = results.reduce((sum, r) => sum + r.stats.patternsMerged, 0);
-    const totalRemoved = results.reduce((sum, r) => sum + r.stats.patternsRemoved, 0);
-    const avgOpportunities =
-      results.reduce((sum, r) => sum + r.stats.improvementOpportunities, 0) /
-      results.length;
-
-    return {
-      consolidations: results.length,
-      totalPatternsMerged: totalMerged,
-      totalPatternsRemoved: totalRemoved,
-      avgImprovementOpportunities: avgOpportunities,
-    };
-  }
-}
-
-// ============================================================================
-// Factory Function
-// ============================================================================
-
-/**
- * Create a Learning Consolidation Protocol instance
- */
-export function createLearningConsolidationProtocol(
-  eventBus: EventBus,
-  memory: MemoryBackend,
-  patternService: IPatternLearningService,
-  knowledgeService: IKnowledgeSynthesisService,
-  config?: Partial<LearningConsolidationConfig>
-): LearningConsolidationProtocol {
-  return new LearningConsolidationProtocol(
-    eventBus,
-    memory,
-    patternService,
-    knowledgeService,
-    config
-  );
-}