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

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

@@ -1,972 +0,0 @@
-/**
- * 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;
-    }
-  }
-}