agentic-qe 3.9.26 → 3.9.28

package/dist/optimization/qe-workers.js

@@ -1,692 +0,0 @@
-/**
- * QE Optimization Workers
- * ADR-024: Self-Optimization Engine
- * ADR-046: V2 Feature Integration (Dream Cycles)
- *
- * Background workers for QE-specific optimization tasks:
- * - Pattern consolidation
- * - Dream cycle consolidation (ADR-046)
- * - Coverage gap scanning
- * - Flaky test detection
- * - Routing accuracy monitoring
- */
-import { BaseWorker } from '../workers/base-worker.js';
-import { toErrorMessage } from '../shared/error-utils.js';
-// ============================================================================
-// Worker Configurations
-// ============================================================================
-/**
- * QE optimization worker configurations
- */
-export const QE_OPTIMIZATION_WORKER_CONFIGS = {
-    'pattern-consolidator': {
-        name: 'Pattern Consolidator',
-        description: 'Consolidates and prunes patterns in the ReasoningBank for optimal memory usage',
-        intervalMs: 30 * 60 * 1000, // 30 minutes
-        priority: 'normal',
-        targetDomains: ['learning-optimization'],
-        enabled: true,
-        timeoutMs: 60 * 1000, // 1 minute
-        retryCount: 2,
-        retryDelayMs: 5000,
-    },
-    'dream-consolidator': {
-        name: 'Dream Cycle Consolidator',
-        description: 'Runs dream cycles to discover novel pattern associations (ADR-046)',
-        intervalMs: 60 * 60 * 1000, // 1 hour (dreams need time to consolidate)
-        priority: 'low', // Dreams run during idle time
-        targetDomains: ['learning-optimization'],
-        enabled: true,
-        timeoutMs: 45 * 1000, // 45 seconds (dream cycle max is 30s + buffer)
-        retryCount: 1,
-        retryDelayMs: 30000, // Wait 30s before retry
-    },
-    'coverage-gap-scanner': {
-        name: 'Coverage Gap Scanner',
-        description: 'Scans codebase for coverage gaps and identifies untested code',
-        intervalMs: 60 * 60 * 1000, // 1 hour
-        priority: 'high',
-        targetDomains: ['coverage-analysis', 'test-generation'],
-        enabled: true,
-        timeoutMs: 120 * 1000, // 2 minutes
-        retryCount: 2,
-        retryDelayMs: 10000,
-    },
-    'flaky-test-detector': {
-        name: 'Flaky Test Detector',
-        description: 'Detects flaky tests by analyzing test execution history and patterns',
-        intervalMs: 2 * 60 * 60 * 1000, // 2 hours
-        priority: 'high',
-        targetDomains: ['test-execution', 'defect-intelligence'],
-        enabled: true,
-        timeoutMs: 180 * 1000, // 3 minutes
-        retryCount: 1,
-        retryDelayMs: 15000,
-    },
-    'routing-accuracy-monitor': {
-        name: 'Routing Accuracy Monitor',
-        description: 'Monitors agent routing accuracy and provides improvement recommendations',
-        intervalMs: 15 * 60 * 1000, // 15 minutes
-        priority: 'critical',
-        targetDomains: ['learning-optimization', 'quality-assessment'],
-        enabled: true,
-        timeoutMs: 30 * 1000, // 30 seconds
-        retryCount: 3,
-        retryDelayMs: 3000,
-    },
-};
-/**
- * Worker that consolidates and prunes patterns in the ReasoningBank
- */
-export class PatternConsolidatorWorker extends BaseWorker {
-    deps;
-    constructor(deps) {
-        super({
-            id: 'pattern-consolidator',
-            ...QE_OPTIMIZATION_WORKER_CONFIGS['pattern-consolidator'],
-        });
-        this.deps = deps;
-    }
-    async doExecute(context) {
-        const startTime = Date.now();
-        const findings = [];
-        const recommendations = [];
-        try {
-            // Get current pattern stats
-            const beforeStats = await this.deps.getPatternStats();
-            context.logger.info(`Pattern stats before: ${JSON.stringify(beforeStats)}`);
-            // Run consolidation
-            const result = await this.deps.consolidatePatterns();
-            // Get stats after consolidation
-            const afterStats = await this.deps.getPatternStats();
-            // Record findings
-            if (result.merged > 0) {
-                findings.push({
-                    type: 'pattern-merged',
-                    severity: 'info',
-                    domain: 'learning-optimization',
-                    title: 'Patterns Merged',
-                    description: `Merged ${result.merged} duplicate pattern groups`,
-                    resource: 'ReasoningBank',
-                });
-            }
-            if (result.pruned > 0) {
-                findings.push({
-                    type: 'pattern-pruned',
-                    severity: 'info',
-                    domain: 'learning-optimization',
-                    title: 'Patterns Pruned',
-                    description: `Pruned ${result.pruned} low-quality patterns`,
-                    resource: 'ReasoningBank',
-                });
-            }
-            // Generate recommendations
-            if (afterStats.duplicateGroups > 10) {
-                recommendations.push({
-                    priority: 'p2',
-                    domain: 'learning-optimization',
-                    action: 'Review patterns with similar embeddings',
-                    description: `${afterStats.duplicateGroups} potential duplicate groups remain. Consider manual review.`,
-                    estimatedImpact: 'medium',
-                    effort: 'medium',
-                    autoFixable: false,
-                });
-            }
-            if (afterStats.lowQuality > afterStats.total * 0.2) {
-                recommendations.push({
-                    priority: 'p1',
-                    domain: 'learning-optimization',
-                    action: 'Review pattern quality thresholds',
-                    description: `${afterStats.lowQuality} low-quality patterns (${((afterStats.lowQuality / afterStats.total) * 100).toFixed(1)}% of total)`,
-                    estimatedImpact: 'high',
-                    effort: 'low',
-                    autoFixable: true,
-                });
-            }
-            const durationMs = Date.now() - startTime;
-            return this.createResult(durationMs, {
-                itemsAnalyzed: beforeStats.total,
-                issuesFound: result.merged + result.pruned,
-                healthScore: Math.max(0, 100 - afterStats.duplicateGroups - afterStats.lowQuality),
-                trend: result.merged + result.pruned > 0 ? 'improving' : 'stable',
-                domainMetrics: {
-                    patternsMerged: result.merged,
-                    patternsPruned: result.pruned,
-                    patternsUpdated: result.updated,
-                    totalPatterns: afterStats.total,
-                },
-            }, findings, recommendations);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}
-/**
- * Worker that runs dream cycles to discover novel pattern associations.
- *
- * ADR-046: V2 Feature Integration - Dream Cycles
- *
- * The dream cycle simulates the consolidation process that occurs during sleep,
- * where the brain strengthens important associations and discovers new connections.
- *
- * This worker:
- * 1. Loads current patterns into the ConceptGraph
- * 2. Runs spreading activation (the "dreaming")
- * 3. Finds novel associations from co-activated concepts
- * 4. Generates insights from activation patterns
- * 5. Applies high-confidence insights as new patterns
- */
-export class DreamConsolidatorWorker extends BaseWorker {
-    deps;
-    dreamDurationMs = 30000; // 30 second dream cycles
-    minConfidenceToApply = 0.7;
-    maxInsightsToApply = 5;
-    constructor(deps) {
-        super({
-            id: 'dream-consolidator',
-            ...QE_OPTIMIZATION_WORKER_CONFIGS['dream-consolidator'],
-        });
-        this.deps = deps;
-    }
-    async doExecute(context) {
-        const startTime = Date.now();
-        const findings = [];
-        const recommendations = [];
-        try {
-            // 1. Check if we have enough patterns to dream about
-            const patternCount = await this.deps.getPatternCount();
-            context.logger.info(`Current pattern count: ${patternCount}`);
-            if (patternCount < 10) {
-                context.logger.info('Insufficient patterns for dreaming, skipping cycle');
-                return this.createResult(Date.now() - startTime, {
-                    itemsAnalyzed: 0,
-                    issuesFound: 0,
-                    healthScore: 50,
-                    trend: 'stable',
-                    domainMetrics: {
-                        patternsLoaded: 0,
-                        dreamCycleRan: 0,
-                        insightsGenerated: 0,
-                        insightsApplied: 0,
-                        reason: 'insufficient-patterns',
-                    },
-                }, findings, recommendations);
-            }
-            // 2. Load patterns into dream engine
-            const patternsLoaded = await this.deps.loadPatternsForDreaming();
-            context.logger.info(`Loaded ${patternsLoaded} patterns for dreaming`);
-            // 3. Run the dream cycle
-            context.logger.info(`Starting dream cycle (${this.dreamDurationMs}ms)`);
-            const dreamResult = await this.deps.runDreamCycle(this.dreamDurationMs);
-            // Record dream cycle finding
-            findings.push({
-                type: 'dream-cycle-completed',
-                severity: 'info',
-                domain: 'learning-optimization',
-                title: 'Dream Cycle Completed',
-                description: `Processed ${dreamResult.activationStats.nodesActivated} concepts, ` +
-                    `found ${dreamResult.cycle.associationsFound} associations, ` +
-                    `generated ${dreamResult.insights.length} insights`,
-                resource: 'DreamEngine',
-                context: {
-                    durationMs: dreamResult.cycle.durationMs,
-                    iterations: dreamResult.activationStats.totalIterations,
-                    peakActivation: dreamResult.activationStats.peakActivation,
-                },
-            });
-            // 4. Apply high-confidence insights
-            let appliedCount = 0;
-            const highConfidenceInsights = dreamResult.insights
-                .filter(i => i.confidenceScore >= this.minConfidenceToApply && i.actionable)
-                .slice(0, this.maxInsightsToApply);
-            for (const insight of highConfidenceInsights) {
-                const applyResult = await this.deps.applyInsight(insight.id);
-                if (applyResult.success && applyResult.patternId) {
-                    appliedCount++;
-                    findings.push({
-                        type: 'insight-applied',
-                        severity: 'info',
-                        domain: 'learning-optimization',
-                        title: `Dream Insight Applied: ${insight.type}`,
-                        description: insight.description,
-                        resource: applyResult.patternId,
-                        context: {
-                            noveltyScore: insight.noveltyScore,
-                            confidenceScore: insight.confidenceScore,
-                        },
-                    });
-                }
-            }
-            // 5. Check for pending insights
-            const pendingInsights = await this.deps.getPendingInsights(20);
-            if (pendingInsights.length > 10) {
-                recommendations.push({
-                    priority: 'p2',
-                    domain: 'learning-optimization',
-                    action: 'Review pending dream insights',
-                    description: `${pendingInsights.length} insights awaiting review. ` +
-                        'Consider lowering confidence threshold or manual review.',
-                    estimatedImpact: 'medium',
-                    effort: 'low',
-                    autoFixable: false,
-                });
-            }
-            // 6. Check dream health
-            if (dreamResult.insights.length === 0 && patternsLoaded >= 20) {
-                recommendations.push({
-                    priority: 'p3',
-                    domain: 'learning-optimization',
-                    action: 'Review dream configuration',
-                    description: 'No insights generated despite sufficient patterns. ' +
-                        'Consider adjusting novelty threshold or spread factor.',
-                    estimatedImpact: 'low',
-                    effort: 'low',
-                    autoFixable: false,
-                });
-            }
-            const durationMs = Date.now() - startTime;
-            const healthScore = Math.min(100, 50 + (dreamResult.insights.length * 5) + (appliedCount * 10));
-            return this.createResult(durationMs, {
-                itemsAnalyzed: patternsLoaded,
-                issuesFound: 0,
-                healthScore,
-                trend: appliedCount > 0 ? 'improving' : 'stable',
-                domainMetrics: {
-                    patternsLoaded,
-                    dreamCycleRan: 1,
-                    conceptsProcessed: dreamResult.activationStats.nodesActivated,
-                    associationsFound: dreamResult.cycle.associationsFound,
-                    insightsGenerated: dreamResult.insights.length,
-                    insightsApplied: appliedCount,
-                    pendingInsights: pendingInsights.length,
-                    durationMs: dreamResult.cycle.durationMs ?? 0,
-                },
-            }, findings, recommendations);
-        }
-        catch (error) {
-            const errorMsg = toErrorMessage(error);
-            // Handle expected errors gracefully
-            if (errorMsg.includes('Insufficient concepts')) {
-                context.logger.info('Dream cycle skipped: insufficient concepts');
-                return this.createResult(Date.now() - startTime, {
-                    itemsAnalyzed: 0,
-                    issuesFound: 0,
-                    healthScore: 50,
-                    trend: 'stable',
-                    domainMetrics: {
-                        dreamCycleRan: 0,
-                        reason: 'insufficient-concepts',
-                    },
-                }, [], []);
-            }
-            throw error;
-        }
-    }
-}
-/**
- * Worker that scans for coverage gaps and queues improvement tasks
- */
-export class CoverageGapScannerWorker extends BaseWorker {
-    deps;
-    constructor(deps) {
-        super({
-            id: 'coverage-gap-scanner',
-            ...QE_OPTIMIZATION_WORKER_CONFIGS['coverage-gap-scanner'],
-        });
-        this.deps = deps;
-    }
-    async doExecute(context) {
-        const startTime = Date.now();
-        const findings = [];
-        const recommendations = [];
-        try {
-            // Find all coverage gaps
-            const gaps = await this.deps.findCoverageGaps();
-            context.logger.info(`Found ${gaps.length} coverage gaps`);
-            // Prioritize gaps
-            const prioritized = await this.deps.prioritizeGaps(gaps.map(g => ({ file: g.file, riskScore: g.riskScore })));
-            // Group gaps by file
-            const gapsByFile = new Map();
-            for (const gap of gaps) {
-                const existing = gapsByFile.get(gap.file) || [];
-                existing.push(gap);
-                gapsByFile.set(gap.file, existing);
-            }
-            // Create findings for high-risk gaps
-            const highRiskGaps = gaps.filter(g => g.riskScore > 0.7);
-            for (const gap of highRiskGaps.slice(0, 10)) {
-                findings.push({
-                    type: 'coverage-gap',
-                    severity: gap.riskScore > 0.9 ? 'critical' : 'high',
-                    domain: 'coverage-analysis',
-                    title: `High-Risk Coverage Gap: ${gap.file}`,
-                    description: `${gap.type} at lines ${gap.startLine}-${gap.endLine} (risk: ${(gap.riskScore * 100).toFixed(0)}%)`,
-                    resource: `${gap.file}:${gap.startLine}`,
-                });
-            }
-            // Queue top priority tasks
-            const topPriority = prioritized.slice(0, 5);
-            for (const task of topPriority) {
-                await this.deps.queueCoverageTask({
-                    file: task.file,
-                    priority: task.priority,
-                });
-            }
-            // Generate recommendations
-            if (highRiskGaps.length > 20) {
-                recommendations.push({
-                    priority: 'p0',
-                    domain: 'coverage-analysis',
-                    action: 'Dedicate sprint time to coverage improvement',
-                    description: `${highRiskGaps.length} high-risk coverage gaps detected`,
-                    estimatedImpact: 'high',
-                    effort: 'high',
-                    autoFixable: false,
-                });
-            }
-            const uncoveredFunctions = gaps.filter(g => g.type === 'uncovered-functions');
-            if (uncoveredFunctions.length > 10) {
-                recommendations.push({
-                    priority: 'p1',
-                    domain: 'test-generation',
-                    action: 'Generate unit tests for untested functions',
-                    description: `${uncoveredFunctions.length} functions have no test coverage`,
-                    estimatedImpact: 'high',
-                    effort: 'medium',
-                    autoFixable: true,
-                });
-            }
-            const durationMs = Date.now() - startTime;
-            return this.createResult(durationMs, {
-                itemsAnalyzed: gapsByFile.size,
-                issuesFound: gaps.length,
-                healthScore: Math.max(0, 100 - (highRiskGaps.length * 2)),
-                trend: gaps.length > 50 ? 'degrading' : 'stable',
-                domainMetrics: {
-                    totalGaps: gaps.length,
-                    highRiskGaps: highRiskGaps.length,
-                    filesAffected: gapsByFile.size,
-                    tasksQueued: topPriority.length,
-                },
-            }, findings, recommendations);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}
-/**
- * Worker that detects flaky tests and queues fix tasks
- */
-export class FlakyTestDetectorWorker extends BaseWorker {
-    deps;
-    constructor(deps) {
-        super({
-            id: 'flaky-test-detector',
-            ...QE_OPTIMIZATION_WORKER_CONFIGS['flaky-test-detector'],
-        });
-        this.deps = deps;
-    }
-    async doExecute(context) {
-        const startTime = Date.now();
-        const findings = [];
-        const recommendations = [];
-        try {
-            // Get test history
-            const testHistory = await this.deps.getTestHistory();
-            context.logger.info(`Analyzing ${testHistory.length} tests for flakiness`);
-            // Detect flaky tests
-            const flakyTests = [];
-            for (const test of testHistory) {
-                if (test.runs < 5)
-                    continue; // Need enough data
-                const passRate = test.passes / test.runs;
-                const durationCoefficient = Math.sqrt(test.durationVariance) / test.avgDuration;
-                // Flakiness indicators
-                let flakinessScore = 0;
-                const reasons = [];
-                // Inconsistent pass/fail rate (not 100% pass or 100% fail)
-                if (passRate > 0.05 && passRate < 0.95) {
-                    flakinessScore += (1 - Math.abs(passRate - 0.5) * 2) * 0.5;
-                    reasons.push(`Inconsistent pass rate: ${(passRate * 100).toFixed(1)}%`);
-                }
-                // High duration variance
-                if (durationCoefficient > 0.5) {
-                    flakinessScore += Math.min(durationCoefficient * 0.3, 0.3);
-                    reasons.push(`High duration variance: ${(durationCoefficient * 100).toFixed(0)}%`);
-                }
-                // Recent failures after passing
-                if (test.failures > 0 && test.passes > 0) {
-                    flakinessScore += 0.2;
-                    reasons.push('Mix of passes and failures');
-                }
-                if (flakinessScore > 0.3) {
-                    flakyTests.push({
-                        testId: test.testId,
-                        testName: test.testName,
-                        filePath: test.filePath,
-                        flakinessScore: Math.min(flakinessScore, 1),
-                        reason: reasons.join('; '),
-                    });
-                }
-            }
-            // Sort by flakiness score
-            flakyTests.sort((a, b) => b.flakinessScore - a.flakinessScore);
-            // Create findings
-            for (const test of flakyTests.slice(0, 15)) {
-                findings.push({
-                    type: 'flaky-test',
-                    severity: test.flakinessScore > 0.7 ? 'high' : 'medium',
-                    domain: 'test-execution',
-                    title: `Flaky Test: ${test.testName}`,
-                    description: test.reason,
-                    resource: test.filePath,
-                    context: {
-                        testId: test.testId,
-                        flakinessScore: test.flakinessScore,
-                    },
-                });
-            }
-            // Queue fix tasks for worst offenders
-            for (const test of flakyTests.slice(0, 5)) {
-                await this.deps.queueFlakyTestFix({
-                    testId: test.testId,
-                    flakinessScore: test.flakinessScore,
-                    reason: test.reason,
-                });
-            }
-            // Generate recommendations
-            if (flakyTests.length > 10) {
-                recommendations.push({
-                    priority: 'p1',
-                    domain: 'test-execution',
-                    action: 'Implement test quarantine and systematic fixes',
-                    description: `${flakyTests.length} flaky tests detected. CI reliability at risk.`,
-                    estimatedImpact: 'high',
-                    effort: 'medium',
-                    autoFixable: false,
-                });
-            }
-            const highVarianceTests = testHistory.filter(t => Math.sqrt(t.durationVariance) / t.avgDuration > 0.8);
-            if (highVarianceTests.length > 5) {
-                recommendations.push({
-                    priority: 'p2',
-                    domain: 'test-execution',
-                    action: 'Review tests for timing-dependent code or resource contention',
-                    description: `${highVarianceTests.length} tests have inconsistent execution times`,
-                    estimatedImpact: 'medium',
-                    effort: 'medium',
-                    autoFixable: false,
-                });
-            }
-            const durationMs = Date.now() - startTime;
-            return this.createResult(durationMs, {
-                itemsAnalyzed: testHistory.length,
-                issuesFound: flakyTests.length,
-                healthScore: Math.max(0, 100 - (flakyTests.length * 3)),
-                trend: flakyTests.length > 20 ? 'degrading' : 'stable',
-                domainMetrics: {
-                    testsAnalyzed: testHistory.length,
-                    flakyTests: flakyTests.length,
-                    highFlakinessTests: flakyTests.filter(t => t.flakinessScore > 0.7).length,
-                    tasksQueued: Math.min(5, flakyTests.length),
-                },
-            }, findings, recommendations);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}
-/**
- * Worker that monitors routing accuracy and triggers retraining
- */
-export class RoutingAccuracyMonitorWorker extends BaseWorker {
-    deps;
-    accuracyThreshold = 0.8;
-    constructor(deps) {
-        super({
-            id: 'routing-accuracy-monitor',
-            ...QE_OPTIMIZATION_WORKER_CONFIGS['routing-accuracy-monitor'],
-        });
-        this.deps = deps;
-    }
-    async doExecute(context) {
-        const startTime = Date.now();
-        const findings = [];
-        const recommendations = [];
-        try {
-            // Get routing stats for the last hour
-            const stats = await this.deps.getRoutingStats(60 * 60 * 1000);
-            context.logger.info(`Routing stats: ${JSON.stringify(stats)}`);
-            // Calculate accuracy
-            const followRate = stats.totalDecisions > 0
-                ? stats.followedRecommendations / stats.totalDecisions
-                : 0;
-            const accuracy = stats.followedRecommendations > 0
-                ? stats.successWhenFollowed / stats.followedRecommendations
-                : 0;
-            // Check if retraining is needed
-            let retrainResult = null;
-            if (accuracy < this.accuracyThreshold && stats.totalDecisions > 10) {
-                context.logger.info(`Accuracy ${accuracy.toFixed(2)} below threshold ${this.accuracyThreshold}, triggering retrain`);
-                retrainResult = await this.deps.retrainRouter();
-                findings.push({
-                    type: 'router-retrained',
-                    severity: 'medium',
-                    domain: 'learning-optimization',
-                    title: 'Router Retrained',
-                    description: `Retrained with ${retrainResult.patternsUsed} patterns. New accuracy: ${(retrainResult.accuracy * 100).toFixed(1)}%`,
-                    resource: 'QERouter',
-                });
-            }
-            // Generate findings for concerning patterns
-            if (followRate < 0.5 && stats.totalDecisions > 20) {
-                findings.push({
-                    type: 'low-follow-rate',
-                    severity: 'high',
-                    domain: 'learning-optimization',
-                    title: 'Low Recommendation Follow Rate',
-                    description: `Only ${(followRate * 100).toFixed(1)}% of recommendations are being followed`,
-                    resource: 'QERouter',
-                });
-            }
-            if (stats.successWhenOverridden > stats.successWhenFollowed && stats.totalDecisions > 20) {
-                findings.push({
-                    type: 'override-better',
-                    severity: 'critical',
-                    domain: 'learning-optimization',
-                    title: 'Override Success Higher Than Follow',
-                    description: 'Overriding recommendations leads to better outcomes than following them',
-                    resource: 'QERouter',
-                });
-            }
-            if (stats.confidenceCorrelation < 0.3 && stats.totalDecisions > 30) {
-                findings.push({
-                    type: 'low-correlation',
-                    severity: 'medium',
-                    domain: 'learning-optimization',
-                    title: 'Low Confidence-Success Correlation',
-                    description: `Confidence scores poorly predict success (correlation: ${stats.confidenceCorrelation.toFixed(2)})`,
-                    resource: 'QERouter',
-                });
-            }
-            // Generate recommendations
-            if (accuracy < this.accuracyThreshold) {
-                recommendations.push({
-                    priority: 'p1',
-                    domain: 'learning-optimization',
-                    action: 'Review and augment training patterns',
-                    description: `Current accuracy ${(accuracy * 100).toFixed(1)}% is below ${(this.accuracyThreshold * 100).toFixed(0)}% threshold`,
-                    estimatedImpact: 'high',
-                    effort: 'medium',
-                    autoFixable: false,
-                });
-            }
-            if (followRate < 0.7) {
-                recommendations.push({
-                    priority: 'p2',
-                    domain: 'learning-optimization',
-                    action: 'Analyze override patterns to improve routing logic',
-                    description: 'Users frequently override recommendations',
-                    estimatedImpact: 'medium',
-                    effort: 'low',
-                    autoFixable: false,
-                });
-            }
-            const durationMs = Date.now() - startTime;
-            const healthScore = Math.round((accuracy * 50) + (followRate * 30) + (stats.confidenceCorrelation * 20));
-            return this.createResult(durationMs, {
-                itemsAnalyzed: stats.totalDecisions,
-                issuesFound: findings.filter(f => f.type === 'issue' || f.type === 'warning').length,
-                healthScore: Math.max(0, Math.min(100, healthScore)),
-                trend: accuracy < this.accuracyThreshold ? 'degrading' : 'stable',
-                domainMetrics: {
-                    totalDecisions: stats.totalDecisions,
-                    accuracy: Math.round(accuracy * 100),
-                    followRate: Math.round(followRate * 100),
-                    confidenceCorrelation: stats.confidenceCorrelation,
-                    retrainTriggered: retrainResult !== null ? 1 : 0,
-                },
-            }, findings, recommendations);
-        }
-        catch (error) {
-            throw error;
-        }
-    }
-}
-// ============================================================================
-// Factory Functions
-// ============================================================================
-/**
- * Create pattern consolidator worker
- */
-export function createPatternConsolidatorWorker(deps) {
-    return new PatternConsolidatorWorker(deps);
-}
-/**
- * Create dream consolidator worker (ADR-046)
- */
-export function createDreamConsolidatorWorker(deps) {
-    return new DreamConsolidatorWorker(deps);
-}
-/**
- * Create coverage gap scanner worker
- */
-export function createCoverageGapScannerWorker(deps) {
-    return new CoverageGapScannerWorker(deps);
-}
-/**
- * Create flaky test detector worker
- */
-export function createFlakyTestDetectorWorker(deps) {
-    return new FlakyTestDetectorWorker(deps);
-}
-/**
- * Create routing accuracy monitor worker
- */
-export function createRoutingAccuracyMonitorWorker(deps) {
-    return new RoutingAccuracyMonitorWorker(deps);
-}
-//# sourceMappingURL=qe-workers.js.map