@agentic-qe/v3 3.0.0-alpha.3

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

@@ -0,0 +1,972 @@
+/**
+ * Agentic QE v3 - Learning Coordinator Service
+ * Orchestrates learning across all QE domains
+ */
+
+import { v4 as uuidv4 } from 'uuid';
+import { Result, ok, err, DomainName } from '../../../shared/types/index.js';
+import { MemoryBackend } from '../../../kernel/interfaces.js';
+import { TimeRange } from '../../../shared/value-objects/index.js';
+import {
+  LearnedPattern,
+  PatternType,
+  PatternContext,
+  PatternTemplate,
+  TemplateVariable,
+  Experience,
+  ExperienceResult,
+  StateSnapshot,
+  MinedInsights,
+  ExperienceCluster,
+  ExperienceAnomaly,
+  PatternStats,
+  IPatternLearningService,
+  IExperienceMiningService,
+  OptimizationObjective,
+} from '../interfaces.js';
+
+/**
+ * Configuration for the learning coordinator
+ */
+export interface LearningCoordinatorConfig {
+  minExperiencesForPattern: number;
+  patternConfidenceThreshold: number;
+  maxPatternsPerDomain: number;
+  anomalyDeviationThreshold: number;
+  clusterSimilarityThreshold: number;
+}
+
+const DEFAULT_CONFIG: LearningCoordinatorConfig = {
+  minExperiencesForPattern: 5,
+  patternConfidenceThreshold: 0.7,
+  maxPatternsPerDomain: 100,
+  anomalyDeviationThreshold: 2.0,
+  clusterSimilarityThreshold: 0.8,
+};
+
+/**
+ * Learning Coordinator Service
+ * Implements pattern learning and experience mining capabilities
+ */
+export class LearningCoordinatorService
+  implements IPatternLearningService, IExperienceMiningService
+{
+  private readonly config: LearningCoordinatorConfig;
+
+  constructor(
+    private readonly memory: MemoryBackend,
+    config: Partial<LearningCoordinatorConfig> = {}
+  ) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  // ============================================================================
+  // IPatternLearningService Implementation
+  // ============================================================================
+
+  /**
+   * Learn a pattern from a set of experiences
+   */
+  async learnPattern(experiences: Experience[]): Promise<Result<LearnedPattern>> {
+    try {
+      if (experiences.length < this.config.minExperiencesForPattern) {
+        return err(
+          new Error(
+            `Need at least ${this.config.minExperiencesForPattern} experiences to learn a pattern`
+          )
+        );
+      }
+
+      // Analyze experiences to extract common patterns
+      const commonActions = this.extractCommonActions(experiences);
+      const successRate = this.calculateSuccessRate(experiences);
+
+      if (successRate < this.config.patternConfidenceThreshold) {
+        return err(
+          new Error(
+            `Success rate ${successRate} below threshold ${this.config.patternConfidenceThreshold}`
+          )
+        );
+      }
+
+      // Determine pattern type from experiences
+      const patternType = this.inferPatternType(experiences);
+      const domain = experiences[0].domain;
+
+      // Generate pattern template
+      const template = this.generatePatternTemplate(experiences, commonActions);
+      const context = this.extractPatternContext(experiences);
+
+      const pattern: LearnedPattern = {
+        id: uuidv4(),
+        type: patternType,
+        domain,
+        name: `${patternType}-${domain}-${Date.now()}`,
+        description: `Learned pattern from ${experiences.length} experiences with ${successRate * 100}% success rate`,
+        confidence: successRate,
+        usageCount: 0,
+        successRate,
+        context,
+        template,
+        createdAt: new Date(),
+        lastUsedAt: new Date(),
+      };
+
+      // Store pattern in memory
+      await this.storePattern(pattern);
+
+      // Record pattern creation for future analysis
+      await this.recordPatternCreation(pattern, experiences);
+
+      return ok(pattern);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Find patterns matching the given context
+   */
+  async findMatchingPatterns(
+    context: PatternContext,
+    limit = 10
+  ): Promise<Result<LearnedPattern[]>> {
+    try {
+      const patterns: LearnedPattern[] = [];
+      const keys = await this.memory.search('learning:pattern:*', 100);
+
+      for (const key of keys) {
+        const pattern = await this.memory.get<LearnedPattern>(key);
+        if (pattern && this.matchesContext(pattern, context)) {
+          patterns.push(pattern);
+        }
+      }
+
+      // Sort by confidence and usage
+      patterns.sort((a, b) => {
+        const scoreA = a.confidence * 0.6 + (a.successRate * 0.4);
+        const scoreB = b.confidence * 0.6 + (b.successRate * 0.4);
+        return scoreB - scoreA;
+      });
+
+      return ok(patterns.slice(0, limit));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Apply a pattern to generate output
+   */
+  async applyPattern(
+    pattern: LearnedPattern,
+    variables: Record<string, unknown>
+  ): Promise<Result<string>> {
+    try {
+      let output = pattern.template.content;
+
+      // Replace template variables
+      for (const variable of pattern.template.variables) {
+        const value = variables[variable.name] ?? variable.defaultValue;
+        if (variable.required && value === undefined) {
+          return err(new Error(`Required variable ${variable.name} not provided`));
+        }
+        output = output.replace(
+          new RegExp(`\\{\\{${variable.name}\\}\\}`, 'g'),
+          String(value ?? '')
+        );
+      }
+
+      // Update pattern usage stats
+      await this.updatePatternUsage(pattern.id);
+
+      return ok(output);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Update pattern based on application feedback
+   */
+  async updatePatternFeedback(
+    patternId: string,
+    success: boolean
+  ): Promise<Result<void>> {
+    try {
+      const key = `learning:pattern:${patternId}`;
+      const pattern = await this.memory.get<LearnedPattern>(key);
+
+      if (!pattern) {
+        return err(new Error(`Pattern ${patternId} not found`));
+      }
+
+      // Update success rate using exponential moving average
+      const alpha = 0.1;
+      const newSuccessRate =
+        alpha * (success ? 1 : 0) + (1 - alpha) * pattern.successRate;
+
+      // Update confidence based on usage count
+      const usageWeight = Math.min(pattern.usageCount / 100, 1);
+      const newConfidence = newSuccessRate * 0.7 + usageWeight * 0.3;
+
+      const updatedPattern: LearnedPattern = {
+        ...pattern,
+        successRate: newSuccessRate,
+        confidence: newConfidence,
+        usageCount: pattern.usageCount + 1,
+        lastUsedAt: new Date(),
+      };
+
+      await this.memory.set(key, updatedPattern, {
+        namespace: 'learning-optimization',
+        persist: true,
+      });
+
+      return ok(undefined);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Consolidate similar patterns into a single improved pattern
+   */
+  async consolidatePatterns(patternIds: string[]): Promise<Result<LearnedPattern>> {
+    try {
+      if (patternIds.length < 2) {
+        return err(new Error('Need at least 2 patterns to consolidate'));
+      }
+
+      const patterns: LearnedPattern[] = [];
+      for (const id of patternIds) {
+        const pattern = await this.memory.get<LearnedPattern>(
+          `learning:pattern:${id}`
+        );
+        if (pattern) {
+          patterns.push(pattern);
+        }
+      }
+
+      if (patterns.length < 2) {
+        return err(new Error('Not enough valid patterns found'));
+      }
+
+      // Merge patterns - take best template, combine contexts
+      const bestPattern = patterns.reduce((best, current) =>
+        current.successRate > best.successRate ? current : best
+      );
+
+      const mergedContext: PatternContext = {
+        language: bestPattern.context.language,
+        framework: bestPattern.context.framework,
+        testType: bestPattern.context.testType,
+        codeContext: bestPattern.context.codeContext,
+        tags: [...new Set(patterns.flatMap((p) => p.context.tags))],
+      };
+
+      const consolidatedPattern: LearnedPattern = {
+        id: uuidv4(),
+        type: bestPattern.type,
+        domain: bestPattern.domain,
+        name: `consolidated-${bestPattern.name}`,
+        description: `Consolidated from ${patterns.length} patterns`,
+        confidence: this.calculateConsolidatedConfidence(patterns),
+        usageCount: patterns.reduce((sum, p) => sum + p.usageCount, 0),
+        successRate: this.calculateWeightedSuccessRate(patterns),
+        context: mergedContext,
+        template: bestPattern.template,
+        createdAt: new Date(),
+        lastUsedAt: new Date(),
+      };
+
+      // Store consolidated pattern
+      await this.storePattern(consolidatedPattern);
+
+      // Archive old patterns
+      for (const pattern of patterns) {
+        await this.archivePattern(pattern.id);
+      }
+
+      return ok(consolidatedPattern);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Get statistics about patterns
+   */
+  async getPatternStats(domain?: DomainName): Promise<Result<PatternStats>> {
+    try {
+      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 && (!domain || pattern.domain === domain)) {
+          patterns.push(pattern);
+        }
+      }
+
+      const byType: Record<PatternType, number> = {
+        'test-pattern': 0,
+        'fix-pattern': 0,
+        'optimization-pattern': 0,
+        'detection-pattern': 0,
+        'workflow-pattern': 0,
+        'failure-pattern': 0,
+      };
+
+      const byDomain: Record<DomainName, number> = {
+        'test-generation': 0,
+        'test-execution': 0,
+        'coverage-analysis': 0,
+        'quality-assessment': 0,
+        'defect-intelligence': 0,
+        'requirements-validation': 0,
+        'code-intelligence': 0,
+        'security-compliance': 0,
+        'contract-testing': 0,
+        'visual-accessibility': 0,
+        'chaos-resilience': 0,
+        'learning-optimization': 0,
+      };
+
+      let totalConfidence = 0;
+      let totalSuccessRate = 0;
+
+      for (const pattern of patterns) {
+        byType[pattern.type]++;
+        byDomain[pattern.domain]++;
+        totalConfidence += pattern.confidence;
+        totalSuccessRate += pattern.successRate;
+      }
+
+      const topPatterns = patterns
+        .sort((a, b) => b.successRate - a.successRate)
+        .slice(0, 10);
+
+      return ok({
+        totalPatterns: patterns.length,
+        byType,
+        byDomain,
+        avgConfidence: patterns.length > 0 ? totalConfidence / patterns.length : 0,
+        avgSuccessRate:
+          patterns.length > 0 ? totalSuccessRate / patterns.length : 0,
+        topPatterns,
+      });
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  // ============================================================================
+  // IExperienceMiningService Implementation
+  // ============================================================================
+
+  /**
+   * Record a new experience
+   */
+  async recordExperience(
+    experience: Omit<Experience, 'id' | 'timestamp'>
+  ): Promise<Result<string>> {
+    try {
+      const id = uuidv4();
+      const fullExperience: Experience = {
+        ...experience,
+        id,
+        timestamp: new Date(),
+      };
+
+      await this.memory.set(`learning:experience:${id}`, fullExperience, {
+        namespace: 'learning-optimization',
+        ttl: 86400 * 30, // 30 days
+      });
+
+      // Index by agent and domain for faster retrieval
+      await this.indexExperience(fullExperience);
+
+      return ok(id);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Mine experiences for insights
+   */
+  async mineExperiences(
+    domain: DomainName,
+    timeRange: TimeRange
+  ): Promise<Result<MinedInsights>> {
+    try {
+      const experiences = await this.getExperiencesByDomainAndTime(
+        domain,
+        timeRange
+      );
+
+      if (experiences.length === 0) {
+        return ok({
+          experienceCount: 0,
+          successRate: 0,
+          avgReward: 0,
+          patterns: [],
+          anomalies: [],
+          recommendations: ['No experiences found in the given time range'],
+        });
+      }
+
+      const successRate = this.calculateSuccessRate(experiences);
+      const avgReward = this.calculateAverageReward(experiences);
+      const patterns = await this.extractPatternsFromExperiences(experiences);
+      const anomalies = this.detectAnomalies(experiences);
+      const recommendations = this.generateRecommendations(
+        experiences,
+        successRate,
+        anomalies
+      );
+
+      return ok({
+        experienceCount: experiences.length,
+        successRate,
+        avgReward,
+        patterns,
+        anomalies,
+        recommendations,
+      });
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Calculate reward for an experience result
+   */
+  calculateReward(result: ExperienceResult, objective: OptimizationObjective): number {
+    const metricValue = (result.outcome[objective.metric] as number) ?? 0;
+
+    // Normalize based on direction
+    let normalizedValue: number;
+    if (objective.direction === 'maximize') {
+      normalizedValue = Math.min(metricValue / 100, 1);
+    } else {
+      normalizedValue = Math.max(1 - metricValue / 100, 0);
+    }
+
+    // Apply constraints as penalties
+    let penalty = 0;
+    for (const constraint of objective.constraints) {
+      const constraintValue = (result.outcome[constraint.metric] as number) ?? 0;
+      const violated = this.isConstraintViolated(constraint, constraintValue);
+      if (violated) {
+        penalty += 0.2;
+      }
+    }
+
+    // Base reward on success and metric value
+    const successBonus = result.success ? 0.5 : 0;
+    const reward = Math.max(0, normalizedValue + successBonus - penalty);
+
+    return Math.min(1, reward);
+  }
+
+  /**
+   * Get experience replay buffer for an agent
+   */
+  async getReplayBuffer(
+    agentId: { value: string; domain: DomainName; type: string },
+    limit = 100
+  ): Promise<Result<Experience[]>> {
+    try {
+      const keys = await this.memory.search(
+        `learning:experience:index:agent:${agentId.value}:*`,
+        limit
+      );
+      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) {
+            experiences.push(experience);
+          }
+        }
+      }
+
+      // Sort by timestamp descending (most recent first)
+      experiences.sort(
+        (a, b) => b.timestamp.getTime() - a.timestamp.getTime()
+      );
+
+      return ok(experiences.slice(0, limit));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Cluster similar experiences
+   */
+  async clusterExperiences(
+    experiences: Experience[]
+  ): Promise<Result<ExperienceCluster[]>> {
+    try {
+      if (experiences.length === 0) {
+        return ok([]);
+      }
+
+      // Simple clustering based on action similarity
+      const clusters: Map<string, Experience[]> = new Map();
+
+      for (const exp of experiences) {
+        let assigned = false;
+        for (const [action, cluster] of clusters) {
+          if (this.actionsSimilar(exp.action, action)) {
+            cluster.push(exp);
+            assigned = true;
+            break;
+          }
+        }
+        if (!assigned) {
+          clusters.set(exp.action, [exp]);
+        }
+      }
+
+      // Convert to ExperienceCluster format
+      const result: ExperienceCluster[] = [];
+      let clusterId = 0;
+
+      for (const [_, clusterExperiences] of clusters) {
+        if (clusterExperiences.length >= 2) {
+          const centroid = this.calculateCentroid(clusterExperiences);
+          const commonActions = this.extractCommonActions(clusterExperiences);
+          const avgReward = this.calculateAverageReward(clusterExperiences);
+
+          result.push({
+            id: `cluster-${clusterId++}`,
+            centroid,
+            experiences: clusterExperiences,
+            commonActions,
+            avgReward,
+          });
+        }
+      }
+
+      return ok(result);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  // ============================================================================
+  // Private Helper Methods
+  // ============================================================================
+
+  private async storePattern(pattern: LearnedPattern): Promise<void> {
+    await this.memory.set(`learning:pattern:${pattern.id}`, pattern, {
+      namespace: 'learning-optimization',
+      persist: true,
+    });
+  }
+
+  private async archivePattern(patternId: string): Promise<void> {
+    const key = `learning:pattern:${patternId}`;
+    const pattern = await this.memory.get<LearnedPattern>(key);
+    if (pattern) {
+      await this.memory.set(`learning:pattern:archived:${patternId}`, pattern, {
+        namespace: 'learning-optimization',
+        persist: true,
+      });
+      await this.memory.delete(key);
+    }
+  }
+
+  private async updatePatternUsage(patternId: string): Promise<void> {
+    const key = `learning:pattern:${patternId}`;
+    const pattern = await this.memory.get<LearnedPattern>(key);
+    if (pattern) {
+      const updated: LearnedPattern = {
+        ...pattern,
+        usageCount: pattern.usageCount + 1,
+        lastUsedAt: new Date(),
+      };
+      await this.memory.set(key, updated, {
+        namespace: 'learning-optimization',
+        persist: true,
+      });
+    }
+  }
+
+  private async recordPatternCreation(
+    pattern: LearnedPattern,
+    experiences: Experience[]
+  ): Promise<void> {
+    await this.memory.set(
+      `learning:pattern:creation:${pattern.id}`,
+      {
+        patternId: pattern.id,
+        experienceIds: experiences.map((e) => e.id),
+        createdAt: new Date(),
+      },
+      { namespace: 'learning-optimization', persist: true }
+    );
+  }
+
+  private async indexExperience(experience: Experience): Promise<void> {
+    // Index by agent
+    await this.memory.set(
+      `learning:experience:index:agent:${experience.agentId.value}:${experience.id}`,
+      experience.id,
+      { namespace: 'learning-optimization', ttl: 86400 * 30 }
+    );
+
+    // Index by domain
+    await this.memory.set(
+      `learning:experience:index:domain:${experience.domain}:${experience.id}`,
+      experience.id,
+      { namespace: 'learning-optimization', ttl: 86400 * 30 }
+    );
+  }
+
+  private async getExperiencesByDomainAndTime(
+    domain: DomainName,
+    timeRange: TimeRange
+  ): Promise<Experience[]> {
+    const keys = await this.memory.search(
+      `learning:experience:index:domain:${domain}:*`,
+      1000
+    );
+    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 experiences;
+  }
+
+  private async extractPatternsFromExperiences(
+    experiences: Experience[]
+  ): Promise<LearnedPattern[]> {
+    // Group successful experiences by action type
+    const successfulExperiences = experiences.filter((e) => e.result.success);
+    const actionGroups: Map<string, Experience[]> = new Map();
+
+    for (const exp of successfulExperiences) {
+      const existing = actionGroups.get(exp.action) || [];
+      existing.push(exp);
+      actionGroups.set(exp.action, existing);
+    }
+
+    const patterns: LearnedPattern[] = [];
+    for (const [_, groupExperiences] of actionGroups) {
+      if (groupExperiences.length >= this.config.minExperiencesForPattern) {
+        const result = await this.learnPattern(groupExperiences);
+        if (result.success) {
+          patterns.push(result.value);
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  private matchesContext(
+    pattern: LearnedPattern,
+    context: PatternContext
+  ): boolean {
+    if (context.language && pattern.context.language !== context.language) {
+      return false;
+    }
+    if (context.framework && pattern.context.framework !== context.framework) {
+      return false;
+    }
+    if (context.testType && pattern.context.testType !== context.testType) {
+      return false;
+    }
+    if (context.tags.length > 0) {
+      const hasMatchingTag = context.tags.some((tag) =>
+        pattern.context.tags.includes(tag)
+      );
+      if (!hasMatchingTag) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  private extractCommonActions(experiences: Experience[]): string[] {
+    const actionCounts: Map<string, number> = new Map();
+    for (const exp of experiences) {
+      const count = actionCounts.get(exp.action) || 0;
+      actionCounts.set(exp.action, count + 1);
+    }
+
+    return Array.from(actionCounts.entries())
+      .filter(([_, count]) => count >= experiences.length * 0.3)
+      .map(([action]) => action);
+  }
+
+  private calculateAverageReward(experiences: Experience[]): number {
+    if (experiences.length === 0) return 0;
+    const sum = experiences.reduce((acc, exp) => acc + exp.reward, 0);
+    return sum / experiences.length;
+  }
+
+  private calculateSuccessRate(experiences: Experience[]): number {
+    if (experiences.length === 0) return 0;
+    const successCount = experiences.filter((e) => e.result.success).length;
+    return successCount / experiences.length;
+  }
+
+  private inferPatternType(experiences: Experience[]): PatternType {
+    const actions = experiences.map((e) => e.action.toLowerCase());
+
+    if (actions.some((a) => a.includes('test') || a.includes('generate'))) {
+      return 'test-pattern';
+    }
+    if (actions.some((a) => a.includes('fix') || a.includes('repair'))) {
+      return 'fix-pattern';
+    }
+    if (actions.some((a) => a.includes('optimize') || a.includes('improve'))) {
+      return 'optimization-pattern';
+    }
+    if (actions.some((a) => a.includes('detect') || a.includes('find'))) {
+      return 'detection-pattern';
+    }
+    if (actions.some((a) => a.includes('workflow') || a.includes('process'))) {
+      return 'workflow-pattern';
+    }
+    if (actions.some((a) => a.includes('fail') || a.includes('error'))) {
+      return 'failure-pattern';
+    }
+
+    return 'workflow-pattern';
+  }
+
+  private generatePatternTemplate(
+    experiences: Experience[],
+    commonActions: string[]
+  ): PatternTemplate {
+    const variables: TemplateVariable[] = [
+      {
+        name: 'domain',
+        type: 'string',
+        required: true,
+        description: 'Target domain for the pattern',
+      },
+      {
+        name: 'action',
+        type: 'string',
+        required: true,
+        defaultValue: commonActions[0],
+        description: 'Primary action to execute',
+      },
+    ];
+
+    const content = `// Pattern learned from ${experiences.length} experiences
+// Common actions: ${commonActions.join(', ')}
+// Apply to domain: {{domain}}
+// Execute action: {{action}}`;
+
+    return {
+      type: 'workflow',
+      content,
+      variables,
+    };
+  }
+
+  private extractPatternContext(experiences: Experience[]): PatternContext {
+    const tags = new Set<string>();
+    let language: string | undefined;
+    let framework: string | undefined;
+
+    for (const exp of experiences) {
+      const context = exp.state.context;
+      if (context.language) {
+        language = context.language as string;
+      }
+      if (context.framework) {
+        framework = context.framework as string;
+      }
+      if (context.tags && Array.isArray(context.tags)) {
+        for (const tag of context.tags) {
+          tags.add(tag as string);
+        }
+      }
+    }
+
+    return {
+      language,
+      framework,
+      tags: Array.from(tags),
+    };
+  }
+
+  private calculateConsolidatedConfidence(patterns: LearnedPattern[]): number {
+    const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
+    let weightedConfidence = 0;
+
+    for (const pattern of patterns) {
+      const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
+      weightedConfidence += pattern.confidence * weight;
+    }
+
+    return weightedConfidence;
+  }
+
+  private calculateWeightedSuccessRate(patterns: LearnedPattern[]): number {
+    const totalUsage = patterns.reduce((sum, p) => sum + p.usageCount, 0);
+    let weightedRate = 0;
+
+    for (const pattern of patterns) {
+      const weight = totalUsage > 0 ? pattern.usageCount / totalUsage : 1 / patterns.length;
+      weightedRate += pattern.successRate * weight;
+    }
+
+    return weightedRate;
+  }
+
+  private detectAnomalies(experiences: Experience[]): ExperienceAnomaly[] {
+    const anomalies: ExperienceAnomaly[] = [];
+    const avgReward = this.calculateAverageReward(experiences);
+    const rewardStdDev = this.calculateStdDev(experiences.map((e) => e.reward));
+
+    for (const exp of experiences) {
+      const deviation = Math.abs(exp.reward - avgReward) / (rewardStdDev || 1);
+
+      if (deviation > this.config.anomalyDeviationThreshold) {
+        let type: ExperienceAnomaly['type'] = 'outlier-reward';
+        if (exp.result.success && exp.reward < avgReward) {
+          type = 'unexpected-success';
+        } else if (!exp.result.success && exp.reward > avgReward) {
+          type = 'unexpected-failure';
+        }
+
+        anomalies.push({
+          experienceId: exp.id,
+          type,
+          description: `Reward ${exp.reward.toFixed(2)} deviates ${deviation.toFixed(2)} std from mean ${avgReward.toFixed(2)}`,
+          deviation,
+        });
+      }
+    }
+
+    return anomalies;
+  }
+
+  private calculateStdDev(values: number[]): number {
+    if (values.length === 0) return 0;
+    const mean = values.reduce((a, b) => a + b, 0) / values.length;
+    const squaredDiffs = values.map((v) => Math.pow(v - mean, 2));
+    return Math.sqrt(squaredDiffs.reduce((a, b) => a + b, 0) / values.length);
+  }
+
+  private generateRecommendations(
+    experiences: Experience[],
+    successRate: number,
+    anomalies: ExperienceAnomaly[]
+  ): string[] {
+    const recommendations: string[] = [];
+
+    if (successRate < 0.5) {
+      recommendations.push(
+        'Low success rate detected. Consider reviewing the approach or gathering more training data.'
+      );
+    }
+
+    if (anomalies.length > experiences.length * 0.1) {
+      recommendations.push(
+        'High anomaly rate detected. Investigate unexpected outcomes for potential improvements.'
+      );
+    }
+
+    const avgDuration =
+      experiences.reduce((sum, e) => sum + e.result.duration, 0) /
+      experiences.length;
+    if (avgDuration > 60000) {
+      recommendations.push(
+        'Average operation duration is high. Consider optimizing performance.'
+      );
+    }
+
+    if (experiences.length < 10) {
+      recommendations.push(
+        'Limited experience data. Collect more data points for better insights.'
+      );
+    }
+
+    if (recommendations.length === 0) {
+      recommendations.push(
+        'Performance metrics are within acceptable ranges. Continue monitoring.'
+      );
+    }
+
+    return recommendations;
+  }
+
+  private actionsSimilar(action1: string, action2: string): boolean {
+    const normalize = (s: string) => s.toLowerCase().replace(/[^a-z]/g, '');
+    const n1 = normalize(action1);
+    const n2 = normalize(action2);
+
+    // Simple similarity check - could be improved with edit distance
+    if (n1 === n2) return true;
+    if (n1.includes(n2) || n2.includes(n1)) return true;
+
+    return false;
+  }
+
+  private calculateCentroid(experiences: Experience[]): StateSnapshot {
+    const avgMetrics: Record<string, number> = {};
+    const metricCounts: Record<string, number> = {};
+
+    for (const exp of experiences) {
+      for (const [key, value] of Object.entries(exp.state.metrics)) {
+        avgMetrics[key] = (avgMetrics[key] || 0) + value;
+        metricCounts[key] = (metricCounts[key] || 0) + 1;
+      }
+    }
+
+    for (const key of Object.keys(avgMetrics)) {
+      avgMetrics[key] /= metricCounts[key];
+    }
+
+    return {
+      context: {},
+      metrics: avgMetrics,
+    };
+  }
+
+  private isConstraintViolated(
+    constraint: { metric: string; operator: string; value: number },
+    actualValue: number
+  ): boolean {
+    switch (constraint.operator) {
+      case 'lt':
+        return actualValue >= constraint.value;
+      case 'gt':
+        return actualValue <= constraint.value;
+      case 'lte':
+        return actualValue > constraint.value;
+      case 'gte':
+        return actualValue < constraint.value;
+      case 'eq':
+        return actualValue !== constraint.value;
+      default:
+        return false;
+    }
+  }
+}