0xray 4.0.13 → 4.0.14

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

@@ -0,0 +1,66 @@
+/**
+ * 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

@@ -0,0 +1,259 @@
+/**
+ * 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

@@ -0,0 +1,79 @@
+/**
+ * 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

@@ -0,0 +1,277 @@
+/**
+ * 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();