0xray 4.0.12 → 4.0.13

package/dist/analytics/emerging-pattern-detector.d.ts

@@ -1,66 +0,0 @@
-/**
- * Emerging Pattern Detector for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Discovers new routing patterns from recent task requests,
- * identifies emergent behaviors, and suggests new pattern candidates.
- *
- * @since 2026-03-05
- */
-import type { EmergentPattern } from "../core/kernel-patterns.js";
-import type { RoutingOutcome } from "../delegation/config/types.js";
-export interface ClusterResult {
-    clusterId: string;
-    patterns: string[];
-    frequency: number;
-    keywords: string[];
-    suggestedAgents: string[];
-    suggestedSkills: string[];
-    confidence: number;
-}
-export interface PatternDiscoveryResult {
-    emergentPatterns: EmergentPattern[];
-    clusters: ClusterResult[];
-    recommendations: string[];
-}
-export declare class EmergingPatternDetector {
-    private readonly minFrequencyThreshold;
-    private readonly minConfidenceThreshold;
-    private readonly clusterSimilarityThreshold;
-    private readonly maxClusters;
-    private readonly stopWords;
-    /**
-     * Extract meaningful keywords from task description
-     */
-    private extractKeywords;
-    /**
-     * Calculate Jaccard similarity between two keyword sets
-     */
-    private calculateSimilarity;
-    /**
-     * Cluster similar task descriptions
-     */
-    private clusterTasks;
-    /**
-     * Detect emergent patterns from recent routing outcomes
-     */
-    detectEmergingPatterns(outcomes: RoutingOutcome[]): PatternDiscoveryResult;
-    /**
-     * Check if a specific pattern is emerging
-     */
-    isPatternEmerging(pattern: string, recentOutcomes: RoutingOutcome[], historicalBaseline: number): {
-        emerging: boolean;
-        trend: 'increasing' | 'decreasing' | 'stable';
-        confidence: number;
-    };
-    /**
-     * Get suggested keyword mappings from emergent patterns
-     */
-    suggestKeywordMappings(emergentPatterns: EmergentPattern[]): Array<{
-        keywords: string[];
-        suggestedAgent: string;
-        suggestedSkill: string;
-        confidence: number;
-        reason: string;
-    }>;
-}
-export declare const emergingPatternDetector: EmergingPatternDetector;

package/dist/analytics/emerging-pattern-detector.js

@@ -1,259 +0,0 @@
-/**
- * Emerging Pattern Detector for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Discovers new routing patterns from recent task requests,
- * identifies emergent behaviors, and suggests new pattern candidates.
- *
- * @since 2026-03-05
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-export class EmergingPatternDetector {
-    minFrequencyThreshold = 3;
-    minConfidenceThreshold = 0.6;
-    clusterSimilarityThreshold = 0.4;
-    maxClusters = 20;
-    stopWords = new Set([
-        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
-        'of', 'with', 'as', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
-        'should', 'may', 'might', 'must', 'can', 'this', 'that', 'these',
-        'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'which'
-    ]);
-    /**
-     * Extract meaningful keywords from task description
-     */
-    extractKeywords(text) {
-        const words = text.toLowerCase()
-            .replace(/[^\w\s]/g, ' ')
-            .split(/\s+/)
-            .filter(word => word.length > 2)
-            .filter(word => !this.stopWords.has(word));
-        return [...new Set(words)];
-    }
-    /**
-     * Calculate Jaccard similarity between two keyword sets
-     */
-    calculateSimilarity(keywords1, keywords2) {
-        if (keywords1.length === 0 || keywords2.length === 0)
-            return 0;
-        const set1 = new Set(keywords1);
-        const set2 = new Set(keywords2);
-        const intersection = new Set([...set1].filter(x => set2.has(x)));
-        const union = new Set([...set1, ...set2]);
-        return intersection.size / union.size;
-    }
-    /**
-     * Cluster similar task descriptions
-     */
-    clusterTasks(tasks) {
-        const clusters = [];
-        const assigned = new Set();
-        // Sort by frequency (most frequent first)
-        const sortedTasks = [...tasks].sort((a, b) => b.keywords.length - a.keywords.length);
-        for (const task of sortedTasks) {
-            if (assigned.has(task.id))
-                continue;
-            // Create new cluster
-            const clusterKeywords = new Set(task.keywords);
-            const clusterDescriptions = [task.description];
-            const clusterIds = [task.id];
-            let clusterFrequency = 1;
-            // Find similar tasks
-            for (const otherTask of sortedTasks) {
-                if (assigned.has(otherTask.id) || otherTask.id === task.id)
-                    continue;
-                const similarity = this.calculateSimilarity([...clusterKeywords], otherTask.keywords);
-                if (similarity >= this.clusterSimilarityThreshold) {
-                    otherTask.keywords.forEach(kw => clusterKeywords.add(kw));
-                    clusterDescriptions.push(otherTask.description);
-                    clusterIds.push(otherTask.id);
-                    clusterFrequency++;
-                    assigned.add(otherTask.id);
-                }
-            }
-            assigned.add(task.id);
-            // Extract unique keywords
-            const uniqueKeywords = [...clusterKeywords].slice(0, 10);
-            // Calculate confidence based on frequency and uniqueness
-            const confidence = Math.min(1, clusterFrequency * 0.15 + uniqueKeywords.length * 0.05);
-            clusters.push({
-                clusterId: `cluster_${clusters.length}`,
-                patterns: clusterDescriptions.slice(0, 5),
-                frequency: clusterFrequency,
-                keywords: uniqueKeywords,
-                suggestedAgents: [],
-                suggestedSkills: [],
-                confidence
-            });
-            if (clusters.length >= this.maxClusters)
-                break;
-        }
-        return clusters;
-    }
-    /**
-     * Detect emergent patterns from recent routing outcomes
-     */
-    detectEmergingPatterns(outcomes) {
-        if (outcomes.length < this.minFrequencyThreshold) {
-            return {
-                emergentPatterns: [],
-                clusters: [],
-                recommendations: ['Insufficient data for pattern detection']
-            };
-        }
-        // Extract keywords and group by outcome
-        const taskData = outcomes.map(outcome => {
-            const keywords = this.extractKeywords(outcome.taskDescription || '');
-            return {
-                id: outcome.taskId,
-                keywords,
-                description: outcome.taskDescription || '',
-                agent: outcome.routedAgent,
-                skill: outcome.routedSkill,
-                success: outcome.success,
-                confidence: outcome.confidence
-            };
-        });
-        // Cluster similar tasks
-        const clusters = this.clusterTasks(taskData);
-        // Analyze clusters for emergent patterns
-        const emergentPatterns = [];
-        const recommendations = [];
-        for (const cluster of clusters) {
-            if (cluster.frequency < this.minFrequencyThreshold)
-                continue;
-            if (cluster.confidence < this.minConfidenceThreshold)
-                continue;
-            // Get success metrics for this cluster
-            const clusterOutcomes = taskData.filter(t => cluster.patterns.includes(t.description));
-            const successCount = clusterOutcomes.filter(t => t.success).length;
-            const successRate = clusterOutcomes.length > 0 ? successCount / clusterOutcomes.length : 0;
-            const avgConfidence = clusterOutcomes.length > 0
-                ? clusterOutcomes.reduce((sum, t) => sum + t.confidence, 0) / clusterOutcomes.length
-                : 0;
-            // Determine suggested agent/skill based on most common
-            const agentCounts = new Map();
-            const skillCounts = new Map();
-            for (const task of clusterOutcomes) {
-                agentCounts.set(task.agent, (agentCounts.get(task.agent) || 0) + 1);
-                skillCounts.set(task.skill, (skillCounts.get(task.skill) || 0) + 1);
-            }
-            const suggestedAgent = [...agentCounts.entries()]
-                .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
-            const suggestedSkill = [...skillCounts.entries()]
-                .sort((a, b) => b[1] - a[1])[0]?.[0] || 'unknown';
-            cluster.suggestedAgents = [suggestedAgent];
-            cluster.suggestedSkills = [suggestedSkill];
-            // Create emergent pattern
-            const emergentPattern = {
-                id: `emergent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
-                pattern: cluster.keywords.join(' | '),
-                trigger: cluster.keywords,
-                action: successRate < 0.7
-                    ? 'Improve routing for this pattern'
-                    : successRate > 0.9
-                        ? 'Add as new keyword mapping'
-                        : 'Monitor pattern performance',
-                confidence: cluster.confidence,
-                category: 'PREVENTION',
-                frequency: cluster.frequency,
-                lastDetected: new Date(),
-                effectiveness: successRate,
-                firstSeen: clusterOutcomes[0]?.success ? new Date() : new Date(),
-                lastSeen: new Date(),
-                evidence: undefined,
-                stringEvidence: cluster.patterns.slice(0, 3),
-                suggestedAction: successRate < 0.7
-                    ? 'Improve routing for this pattern'
-                    : successRate > 0.9
-                        ? 'Add as new keyword mapping'
-                        : 'Monitor pattern performance'
-            };
-            // Determine if pattern is truly emergent (not in existing mappings)
-            const isNewPattern = successRate > 0.7 && cluster.frequency >= 5;
-            if (isNewPattern) {
-                emergentPatterns.push(emergentPattern);
-            }
-            // Generate recommendations
-            if (successRate > 0.9 && cluster.frequency >= 5) {
-                recommendations.push(`High-performing pattern "${cluster.keywords.slice(0, 3).join(', ')}" (${cluster.frequency} uses, ${(successRate * 100).toFixed(0)}% success) - Consider adding as new keyword mapping`);
-            }
-            else if (successRate < 0.6 && cluster.frequency >= 3) {
-                recommendations.push(`Underperforming pattern "${cluster.keywords.slice(0, 3).join(', ')}" (${cluster.frequency} uses, ${(successRate * 100).toFixed(0)}% success) - Review routing logic`);
-            }
-        }
-        // Sort emergent patterns by confidence
-        emergentPatterns.sort((a, b) => b.confidence - a.confidence);
-        if (recommendations.length === 0) {
-            recommendations.push('No significant emergent patterns detected');
-        }
-        frameworkLogger.log("emerging-pattern-detector", "analysis-complete", "info", {
-            emergentPatternsCount: emergentPatterns.length,
-            clustersCount: clusters.length,
-            recommendationsCount: recommendations.length
-        }, undefined);
-        return {
-            emergentPatterns,
-            clusters,
-            recommendations
-        };
-    }
-    /**
-     * Check if a specific pattern is emerging
-     */
-    isPatternEmerging(pattern, recentOutcomes, historicalBaseline) {
-        const keywords = this.extractKeywords(pattern);
-        const recentKeywords = recentOutcomes.slice(-20).map(o => this.extractKeywords(o.taskDescription || ''));
-        // Count matches in recent outcomes
-        let matches = 0;
-        for (const recentKw of recentKeywords) {
-            if (this.calculateSimilarity(keywords, recentKw) > this.clusterSimilarityThreshold) {
-                matches++;
-            }
-        }
-        const recentFrequency = matches / Math.max(recentKeywords.length, 1);
-        const baselineFrequency = historicalBaseline;
-        // Determine trend
-        let trend;
-        if (recentFrequency > baselineFrequency * 1.3) {
-            trend = 'increasing';
-        }
-        else if (recentFrequency < baselineFrequency * 0.7) {
-            trend = 'decreasing';
-        }
-        else {
-            trend = 'stable';
-        }
-        return {
-            emerging: trend === 'increasing' && recentFrequency > 0.1,
-            trend,
-            confidence: Math.min(1, recentFrequency * 2)
-        };
-    }
-    /**
-     * Get suggested keyword mappings from emergent patterns
-     */
-    suggestKeywordMappings(emergentPatterns) {
-        const suggestions = [];
-        for (const pattern of emergentPatterns) {
-            if (pattern.confidence < this.minConfidenceThreshold)
-                continue;
-            // Extract top keywords as potential mapping
-            const keywords = pattern.pattern.split(' | ').slice(0, 5);
-            // Extract agent/skill from evidence
-            // In real implementation, this would analyze the evidence
-            const suggestedAgent = 'orchestrator'; // Default fallback
-            const suggestedSkill = 'orchestrator';
-            suggestions.push({
-                keywords,
-                suggestedAgent,
-                suggestedSkill,
-                confidence: pattern.confidence,
-                reason: `Emerging pattern with ${pattern.frequency} occurrences`
-            });
-        }
-        return suggestions;
-    }
-}
-// Singleton instance
-export const emergingPatternDetector = new EmergingPatternDetector();

package/dist/analytics/pattern-learning-engine.d.ts

@@ -1,79 +0,0 @@
-/**
- * Pattern Learning Engine for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Learns from performance data, generates adaptive modifications,
- * and creates self-improving pattern definitions.
- *
- * @since 2026-03-05
- */
-import type { PatternUpdate } from "../core/kernel-patterns.js";
-export interface LearningResult {
-    newPatterns: PatternUpdate[];
-    modifiedPatterns: PatternUpdate[];
-    removedPatterns: PatternUpdate[];
-    thresholdUpdates: PatternUpdate[];
-    recommendations: string[];
-}
-export interface AdaptiveLearningConfig {
-    enableAutoAddition: boolean;
-    enableAutoRemoval: boolean;
-    enableThresholdCalibration: boolean;
-    minConfidenceForAddition: number;
-    minSuccessRateForAddition: number;
-    maxPatterns: number;
-}
-export declare class PatternLearningEngine {
-    private config;
-    private learningHistory;
-    private readonly maxHistory;
-    constructor(config?: Partial<AdaptiveLearningConfig>);
-    /**
-     * Main learning function - analyzes data and generates adaptive modifications
-     */
-    learnFromData(outcomes: Array<{
-        taskId: string;
-        taskDescription: string;
-        routedAgent: string;
-        routedSkill: string;
-        confidence: number;
-        success: boolean;
-    }>, existingMappings: Array<{
-        keywords: string[];
-        skill: string;
-        agent: string;
-        confidence: number;
-    }>): LearningResult;
-    /**
-     * Generate pattern modifications based on performance
-     */
-    private generatePatternModifications;
-    /**
-     * Generate patterns for removal based on poor performance
-     */
-    private generatePatternRemovals;
-    /**
-     * Generate adaptive threshold updates
-     */
-    private generateThresholdUpdates;
-    /**
-     * Generate new pattern suggestions from emergent patterns
-     */
-    private generateNewPatterns;
-    /**
-     * Generate recommendations based on learning results
-     */
-    private generateRecommendations;
-    /**
-     * Get learning history
-     */
-    getLearningHistory(): LearningResult[];
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig: Partial<AdaptiveLearningConfig>): void;
-    /**
-     * Get current configuration
-     */
-    getConfig(): AdaptiveLearningConfig;
-}
-export declare const patternLearningEngine: PatternLearningEngine;

package/dist/analytics/pattern-learning-engine.js

@@ -1,277 +0,0 @@
-/**
- * Pattern Learning Engine for P9 - ADAPTIVE_PATTERN_LEARNING
- *
- * Learns from performance data, generates adaptive modifications,
- * and creates self-improving pattern definitions.
- *
- * @since 2026-03-05
- */
-import { frameworkLogger } from "../core/framework-logger.js";
-import { patternPerformanceTracker } from "./pattern-performance-tracker.js";
-import { emergingPatternDetector } from "./emerging-pattern-detector.js";
-export class PatternLearningEngine {
-    config;
-    learningHistory = [];
-    maxHistory = 100;
-    constructor(config) {
-        this.config = {
-            enableAutoAddition: config?.enableAutoAddition ?? true,
-            enableAutoRemoval: config?.enableAutoRemoval ?? true,
-            enableThresholdCalibration: config?.enableThresholdCalibration ?? true,
-            minConfidenceForAddition: config?.minConfidenceForAddition ?? 0.8,
-            minSuccessRateForAddition: config?.minSuccessRateForAddition ?? 0.85,
-            maxPatterns: config?.maxPatterns ?? 500
-        };
-    }
-    /**
-     * Main learning function - analyzes data and generates adaptive modifications
-     */
-    learnFromData(outcomes, existingMappings) {
-        const result = {
-            newPatterns: [],
-            modifiedPatterns: [],
-            removedPatterns: [],
-            thresholdUpdates: [],
-            recommendations: []
-        };
-        // Track performance for each agent:skill combination
-        const agentSkillMetrics = new Map();
-        for (const outcome of outcomes) {
-            const patternId = `${outcome.routedAgent}:${outcome.routedSkill}`;
-            // Track in performance tracker
-            patternPerformanceTracker.trackPatternPerformance(patternId, {
-                success: outcome.success,
-                confidence: outcome.confidence
-            });
-            // Track in local metrics
-            if (!agentSkillMetrics.has(patternId)) {
-                agentSkillMetrics.set(patternId, {
-                    patternId,
-                    totalUsages: 0,
-                    successfulUsages: 0,
-                    failedUsages: 0,
-                    successRate: 0,
-                    avgConfidence: 0,
-                    avgResponseTime: 0,
-                    lastUpdated: new Date(),
-                    timeSeries: []
-                });
-            }
-            const metrics = agentSkillMetrics.get(patternId);
-            metrics.totalUsages++;
-            if (outcome.success) {
-                metrics.successfulUsages++;
-            }
-            else {
-                metrics.failedUsages++;
-            }
-            metrics.successRate = metrics.successfulUsages / metrics.totalUsages;
-            metrics.avgConfidence = (metrics.avgConfidence * 0.9) + (outcome.confidence * 0.1);
-            metrics.lastUpdated = new Date();
-        }
-        // Generate pattern modifications
-        result.modifiedPatterns = this.generatePatternModifications(agentSkillMetrics);
-        result.removedPatterns = this.generatePatternRemovals(agentSkillMetrics, existingMappings);
-        // Generate threshold updates
-        if (this.config.enableThresholdCalibration) {
-            result.thresholdUpdates = this.generateThresholdUpdates(agentSkillMetrics);
-        }
-        // Detect emerging patterns for new additions
-        if (this.config.enableAutoAddition) {
-            const emergentResult = emergingPatternDetector.detectEmergingPatterns(outcomes.map(o => ({
-                taskId: o.taskId,
-                taskDescription: o.taskDescription,
-                routedAgent: o.routedAgent,
-                routedSkill: o.routedSkill,
-                confidence: o.confidence,
-                timestamp: new Date(),
-                success: o.success
-            })));
-            result.newPatterns = this.generateNewPatterns(emergentResult.emergentPatterns, existingMappings);
-        }
-        // Generate recommendations
-        result.recommendations = this.generateRecommendations(result);
-        // Store in history
-        this.learningHistory.push(result);
-        if (this.learningHistory.length > this.maxHistory) {
-            this.learningHistory.shift();
-        }
-        frameworkLogger.log("pattern-learning-engine", "learning-complete", "info", {
-            newPatterns: result.newPatterns.length,
-            modifiedPatterns: result.modifiedPatterns.length,
-            removedPatterns: result.removedPatterns.length,
-            thresholdUpdates: result.thresholdUpdates.length
-        }, undefined);
-        return result;
-    }
-    /**
-     * Generate pattern modifications based on performance
-     */
-    generatePatternModifications(metrics) {
-        const updates = [];
-        for (const [patternId, metric] of metrics.entries()) {
-            // Skip if not enough data
-            if (metric.totalUsages < 5)
-                continue;
-            // Check for confidence adjustment needed
-            if (Math.abs(metric.avgConfidence - 0.75) > 0.15) {
-                const newConfidence = Math.max(0.5, Math.min(0.99, metric.successRate));
-                updates.push({
-                    updateType: 'modify',
-                    patternId,
-                    changes: [
-                        { type: 'CONFIDENCE', oldValue: metric.avgConfidence, newValue: newConfidence }
-                    ],
-                    type: 'CONFIDENCE',
-                    oldValue: metric.avgConfidence,
-                    newValue: newConfidence,
-                    timestamp: new Date(),
-                    reason: `Performance-based confidence adjustment: ${metric.successRate.toFixed(2)} success rate`,
-                    confidence: Math.min(1, metric.totalUsages / 20),
-                    validated: false
-                });
-            }
-        }
-        return updates;
-    }
-    /**
-     * Generate patterns for removal based on poor performance
-     */
-    generatePatternRemovals(metrics, existingMappings) {
-        const removals = [];
-        for (const [patternId, metric] of metrics.entries()) {
-            // Skip if not enough data
-            if (metric.totalUsages < 10)
-                continue;
-            // Remove if success rate is too low
-            if (metric.successRate < 0.4 && metric.totalUsages >= 20) {
-                // Find the corresponding mapping
-                const [agent, skill] = patternId.includes(':') ? patternId.split(':') : [patternId, 'default'];
-                removals.push({
-                    updateType: 'remove',
-                    patternId,
-                    changes: [
-                        { type: 'REMOVAL', oldValue: patternId, newValue: 'REMOVED' }
-                    ],
-                    type: 'FREQUENCY',
-                    oldValue: patternId,
-                    newValue: 'REMOVED',
-                    timestamp: new Date(),
-                    reason: `Low success rate: ${(metric.successRate * 100).toFixed(1)}% over ${metric.totalUsages} usages`,
-                    confidence: Math.min(1, metric.totalUsages / 30),
-                    validated: false
-                });
-            }
-        }
-        return removals;
-    }
-    /**
-     * Generate adaptive threshold updates
-     */
-    generateThresholdUpdates(metrics) {
-        const updates = [];
-        // Get adaptive thresholds from performance tracker
-        const thresholds = patternPerformanceTracker.calculateAdaptiveThresholds();
-        // Generate updates for agents with enough data
-        if (thresholds.perAgent) {
-            for (const [agent, threshold] of Object.entries(thresholds.perAgent)) {
-                const metric = metrics.get(agent);
-                if (metric && metric.totalUsages >= 10) {
-                    updates.push({
-                        updateType: 'modify',
-                        patternId: `threshold:${agent}`,
-                        changes: [
-                            { type: 'TRIGGER', oldValue: agent, newValue: JSON.stringify(threshold) }
-                        ],
-                        type: 'TRIGGER',
-                        oldValue: agent,
-                        newValue: JSON.stringify(threshold),
-                        timestamp: new Date(),
-                        reason: `Adaptive threshold calibration based on ${metric.totalUsages} historical usages`,
-                        confidence: Math.min(1, metric.totalUsages / 20),
-                        validated: false
-                    });
-                }
-            }
-        }
-        return updates;
-    }
-    /**
-     * Generate new pattern suggestions from emergent patterns
-     */
-    generateNewPatterns(emergentPatterns, existingMappings) {
-        const newPatterns = [];
-        for (const emergent of emergentPatterns) {
-            // Skip if confidence is too low
-            if (emergent.confidence < this.config.minConfidenceForAddition)
-                continue;
-            // Check if pattern already exists
-            const keywords = emergent.pattern.split(' | ');
-            const existingMatch = existingMappings.find(m => m.keywords.some(kw => keywords.includes(kw)));
-            if (existingMatch)
-                continue; // Don't add duplicate
-            // Add as new pattern
-            newPatterns.push({
-                updateType: 'add',
-                patternId: `emerging_${emergent.pattern.substring(0, 20)}`,
-                changes: [
-                    { type: 'ACTION', oldValue: '', newValue: emergent.suggestedAction || 'monitor' }
-                ],
-                type: 'ACTION',
-                oldValue: '',
-                newValue: JSON.stringify({ keywords, confidence: emergent.confidence }),
-                timestamp: new Date(),
-                reason: `Emerging pattern with ${emergent.frequency} occurrences and ${(emergent.confidence * 100).toFixed(0)}% confidence`,
-                confidence: emergent.confidence,
-                validated: false
-            });
-        }
-        return newPatterns;
-    }
-    /**
-     * Generate recommendations based on learning results
-     */
-    generateRecommendations(result) {
-        const recommendations = [];
-        if (result.newPatterns.length > 0) {
-            recommendations.push(`${result.newPatterns.length} new patterns detected - review for addition`);
-        }
-        if (result.modifiedPatterns.length > 0) {
-            recommendations.push(`${result.modifiedPatterns.length} patterns recommended for confidence adjustment`);
-        }
-        if (result.removedPatterns.length > 0) {
-            recommendations.push(`${result.removedPatterns.length} underperforming patterns recommended for removal`);
-        }
-        if (result.thresholdUpdates.length > 0) {
-            recommendations.push(`${result.thresholdUpdates.length} adaptive threshold updates available`);
-        }
-        if (recommendations.length === 0) {
-            recommendations.push('No pattern modifications recommended at this time');
-        }
-        return recommendations;
-    }
-    /**
-     * Get learning history
-     */
-    getLearningHistory() {
-        return [...this.learningHistory];
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(newConfig) {
-        this.config = {
-            ...this.config,
-            ...newConfig
-        };
-        frameworkLogger.log("pattern-learning-engine", "config-updated", "info", { config: this.config }, undefined);
-    }
-    /**
-     * Get current configuration
-     */
-    getConfig() {
-        return { ...this.config };
-    }
-}
-// Singleton instance
-export const patternLearningEngine = new PatternLearningEngine();