agentic-flow 2.0.2 → 2.0.4

package/dist/workers/dispatch-service.js

@@ -1,1024 +0,0 @@
-/**
- * WorkerDispatchService - Dispatches and manages background workers
- *
- * Integrates with RuVector ecosystem:
- * - SONA: Self-learning trajectory tracking
- * - ReasoningBank: Pattern storage and memory retrieval
- * - HNSW: Vector indexing for semantic search
- */
-import { EventEmitter } from 'events';
-import { getWorkerRegistry } from './worker-registry.js';
-import { getResourceGovernor } from './resource-governor.js';
-import { getTriggerDetector } from './trigger-detector.js';
-import { getRuVectorWorkerIntegration, createRuVectorWorkerContext } from './ruvector-integration.js';
-import { customWorkerManager } from './custom-worker-factory.js';
-export class WorkerDispatchService extends EventEmitter {
-    registry;
-    governor;
-    detector;
-    ruvector;
-    runningWorkers = new Map();
-    workerImplementations = new Map();
-    constructor() {
-        super();
-        this.registry = getWorkerRegistry();
-        this.governor = getResourceGovernor();
-        this.detector = getTriggerDetector();
-        this.ruvector = getRuVectorWorkerIntegration();
-        this.registerDefaultWorkers();
-        // Initialize RuVector in background
-        this.ruvector.initialize().catch(err => {
-            console.warn('[WorkerDispatch] RuVector init failed:', err);
-        });
-    }
-    /**
-     * Dispatch a worker based on trigger
-     */
-    async dispatch(trigger, topic, sessionId) {
-        // Check if we can spawn
-        const canSpawn = this.governor.canSpawn(trigger);
-        if (!canSpawn.allowed) {
-            throw new Error(`Cannot spawn worker: ${canSpawn.reason}`);
-        }
-        // Create worker entry
-        const workerId = this.registry.create(trigger, sessionId, topic);
-        // Get worker info
-        const workerInfo = this.registry.get(workerId);
-        if (!workerInfo) {
-            throw new Error('Failed to create worker entry');
-        }
-        // Register with governor
-        this.governor.register(workerInfo);
-        // Create abort controller
-        const abortController = new AbortController();
-        this.runningWorkers.set(workerId, abortController);
-        // Start worker in background
-        this.executeWorker(workerId, trigger, topic, sessionId, abortController.signal);
-        this.emit('worker:spawned', { workerId, trigger, topic, sessionId });
-        return workerId;
-    }
-    /**
-     * Detect triggers in prompt and dispatch workers
-     * @param parallel - Enable parallel dispatch for better batch performance (default: true)
-     */
-    async dispatchFromPrompt(prompt, sessionId, options = {}) {
-        const triggers = this.detector.detect(prompt);
-        const { parallel = true } = options;
-        if (parallel && triggers.length > 1) {
-            // Parallel dispatch for better batch performance
-            const results = await Promise.allSettled(triggers.map(trigger => this.dispatch(trigger.keyword, trigger.topic, sessionId)));
-            const workerIds = [];
-            results.forEach((result, index) => {
-                if (result.status === 'fulfilled') {
-                    workerIds.push(result.value);
-                }
-                else {
-                    console.warn(`Failed to dispatch ${triggers[index].keyword}:`, result.reason);
-                }
-            });
-            return { triggers, workerIds };
-        }
-        // Sequential dispatch (fallback)
-        const workerIds = [];
-        for (const trigger of triggers) {
-            try {
-                const workerId = await this.dispatch(trigger.keyword, trigger.topic, sessionId);
-                workerIds.push(workerId);
-            }
-            catch (error) {
-                console.warn(`Failed to dispatch ${trigger.keyword}:`, error);
-            }
-        }
-        return { triggers, workerIds };
-    }
-    /**
-     * Execute worker in background with RuVector integration
-     */
-    async executeWorker(workerId, trigger, topic, sessionId, signal) {
-        const startTime = Date.now();
-        // Update status to running
-        this.registry.updateStatus(workerId, 'running');
-        this.governor.update(workerId, { status: 'running', startedAt: startTime });
-        // Initialize RuVector trajectory tracking
-        let ruvectorContext = null;
-        let phaseStartTime = startTime;
-        let currentPhaseDeposits = 0;
-        try {
-            ruvectorContext = await createRuVectorWorkerContext({
-                workerId,
-                trigger,
-                topic,
-                sessionId,
-                startTime,
-                signal,
-                onProgress: () => { },
-                onMemoryDeposit: () => { }
-            });
-        }
-        catch (e) {
-            // RuVector is optional - continue without it
-        }
-        // Create context with RuVector-enhanced callbacks
-        const context = {
-            workerId,
-            trigger,
-            topic,
-            sessionId,
-            startTime,
-            signal,
-            onProgress: async (progress, phase) => {
-                const now = Date.now();
-                const phaseDuration = now - phaseStartTime;
-                this.registry.updateStatus(workerId, 'running', { progress, currentPhase: phase });
-                this.governor.update(workerId, { progress, currentPhase: phase });
-                this.emit('worker:progress', { workerId, progress, phase });
-                // Record phase in RuVector trajectory
-                if (ruvectorContext) {
-                    try {
-                        await ruvectorContext.recordStep(phase, {
-                            duration: phaseDuration,
-                            memoryDeposits: currentPhaseDeposits,
-                            successRate: Math.min(1, progress / 100)
-                        });
-                    }
-                    catch (e) {
-                        // Best effort
-                    }
-                }
-                // Reset phase tracking
-                phaseStartTime = now;
-                currentPhaseDeposits = 0;
-            },
-            onMemoryDeposit: (key) => {
-                currentPhaseDeposits++;
-                this.registry.incrementMemoryDeposits(workerId, key);
-                this.emit('worker:deposit', { workerId, key });
-            }
-        };
-        try {
-            // Get worker implementation
-            const implementation = this.workerImplementations.get(trigger);
-            if (!implementation) {
-                throw new Error(`No implementation for worker type: ${trigger}`);
-            }
-            // Find relevant patterns from previous runs
-            if (ruvectorContext) {
-                try {
-                    const patterns = await ruvectorContext.findPatterns(3);
-                    if (patterns.length > 0) {
-                        this.emit('worker:patterns', { workerId, patterns });
-                    }
-                }
-                catch (e) {
-                    // Best effort
-                }
-            }
-            // Execute worker
-            const results = await implementation(context);
-            // Complete RuVector trajectory and trigger learning
-            if (ruvectorContext) {
-                try {
-                    const learningResult = await ruvectorContext.complete(results);
-                    this.emit('worker:learning', { workerId, ...learningResult });
-                }
-                catch (e) {
-                    // Best effort
-                }
-            }
-            // Update status with actual results data
-            this.registry.updateStatus(workerId, 'complete', {
-                results: results.data
-            });
-            this.governor.unregister(workerId);
-            this.emit('worker:complete', { workerId, results, duration: Date.now() - startTime });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Complete trajectory with failure
-            if (ruvectorContext) {
-                try {
-                    await ruvectorContext.complete({
-                        status: signal.aborted ? 'cancelled' : 'failed',
-                        data: { error: errorMessage },
-                        completedPhases: 0,
-                        totalPhases: 1,
-                        memoryKeys: [],
-                        duration: Date.now() - startTime
-                    });
-                }
-                catch (e) {
-                    // Best effort
-                }
-            }
-            // Check if aborted
-            if (signal.aborted) {
-                this.registry.updateStatus(workerId, 'cancelled', { error: 'Worker cancelled' });
-            }
-            else {
-                this.registry.updateStatus(workerId, 'failed', { error: errorMessage });
-            }
-            this.governor.unregister(workerId);
-            this.emit('worker:error', { workerId, error: errorMessage });
-        }
-        finally {
-            this.runningWorkers.delete(workerId);
-        }
-    }
-    /**
-     * Get worker status
-     */
-    getStatus(workerId) {
-        return this.registry.get(workerId);
-    }
-    /**
-     * Get all workers
-     */
-    getAllWorkers(sessionId) {
-        return this.registry.getAll({ sessionId });
-    }
-    /**
-     * Get active workers
-     */
-    getActiveWorkers(sessionId) {
-        return this.registry.getActive(sessionId);
-    }
-    /**
-     * Cancel a running worker
-     */
-    cancel(workerId) {
-        const controller = this.runningWorkers.get(workerId);
-        if (!controller) {
-            return false;
-        }
-        controller.abort();
-        return true;
-    }
-    /**
-     * Wait for worker completion
-     */
-    async awaitCompletion(workerId, timeout = 300000) {
-        return new Promise((resolve) => {
-            const checkInterval = setInterval(() => {
-                const worker = this.registry.get(workerId);
-                if (!worker) {
-                    clearInterval(checkInterval);
-                    resolve(null);
-                    return;
-                }
-                if (['complete', 'failed', 'cancelled', 'timeout'].includes(worker.status)) {
-                    clearInterval(checkInterval);
-                    resolve(worker);
-                }
-            }, 500);
-            // Timeout
-            setTimeout(() => {
-                clearInterval(checkInterval);
-                resolve(this.registry.get(workerId));
-            }, timeout);
-        });
-    }
-    /**
-     * Register a worker implementation
-     */
-    registerWorker(trigger, implementation) {
-        this.workerImplementations.set(trigger, implementation);
-    }
-    /**
-     * Register a custom worker from definition
-     */
-    registerCustomWorker(worker) {
-        const name = worker.definition.name;
-        // Create implementation that delegates to the custom worker
-        const implementation = async (context) => {
-            const result = await worker.execute(context);
-            return {
-                success: result.success,
-                data: result.data,
-                status: result.success ? 'complete' : 'failed',
-                completedPhases: worker.definition.phases.length,
-                totalPhases: worker.definition.phases.length,
-                memoryKeys: [],
-                duration: result.data.executionTimeMs || 0
-            };
-        };
-        // Register main name
-        this.registerWorker(name, implementation);
-        // Register aliases
-        for (const trigger of worker.definition.triggers || []) {
-            this.registerWorker(trigger.toLowerCase(), implementation);
-        }
-        // Also add to trigger detector
-        this.detector.registerTrigger({
-            keyword: name,
-            priority: worker.definition.priority || 'medium',
-            description: worker.definition.description,
-            timeout: worker.definition.timeout || 120000,
-            cooldown: worker.definition.cooldown || 5000,
-            topicExtractor: worker.definition.topicExtractor
-                ? new RegExp(worker.definition.topicExtractor, 'i')
-                : undefined
-        });
-    }
-    /**
-     * Load and register custom workers from config file
-     */
-    async loadCustomWorkers(configPath) {
-        const count = await customWorkerManager.loadFromConfig(configPath);
-        // Register each loaded worker
-        for (const worker of customWorkerManager.list()) {
-            this.registerCustomWorker(worker);
-        }
-        return count;
-    }
-    /**
-     * Check if a trigger has a custom worker
-     */
-    hasCustomWorker(trigger) {
-        return customWorkerManager.get(trigger) !== undefined;
-    }
-    /**
-     * Get available custom worker presets
-     */
-    getCustomWorkerPresets() {
-        return customWorkerManager.listPresets();
-    }
-    /**
-     * Register default worker implementations
-     */
-    registerDefaultWorkers() {
-        // Import worker implementations
-        this.registerWorker('ultralearn', this.createUltralearnWorker());
-        this.registerWorker('optimize', this.createOptimizeWorker());
-        this.registerWorker('consolidate', this.createConsolidateWorker());
-        this.registerWorker('predict', this.createPredictWorker());
-        this.registerWorker('audit', this.createAuditWorker());
-        this.registerWorker('map', this.createMapWorker());
-        this.registerWorker('preload', this.createPreloadWorker());
-        this.registerWorker('deepdive', this.createDeepdiveWorker());
-        this.registerWorker('document', this.createDocumentWorker());
-        this.registerWorker('refactor', this.createRefactorWorker());
-        this.registerWorker('benchmark', this.createBenchmarkWorker());
-        this.registerWorker('testgaps', this.createTestgapsWorker());
-    }
-    // Worker implementations
-    createUltralearnWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['discovery', 'analysis', 'relationship', 'vectorization', 'summarization', 'indexing'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                // Simulate work with actual operations
-                await this.executePhase('ultralearn', phase, topic, context);
-                const key = `ultralearn/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            // Get real analysis results
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId); // Clean up
-            return {
-                status: 'complete',
-                data: {
-                    topic,
-                    phases: phases.length,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes,
-                    sample_patterns: analysisResults.patterns.slice(0, 5)
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createOptimizeWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['pattern-analysis', 'bottleneck-detect', 'cache-warmup', 'route-optimize'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('optimize', phase, topic, context);
-                const key = `optimize/${context.sessionId}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    optimized: true,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createConsolidateWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal } = context;
-            const phases = ['inventory', 'similarity', 'merge', 'prune', 'reindex'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('consolidate', phase, null, context);
-                const key = `consolidate/report/${Date.now()}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    consolidated: true,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createPredictWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['context-gather', 'pattern-match', 'predict', 'preload'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('predict', phase, topic, context);
-                const key = `predict/${context.sessionId}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    predictions: analysisResults.patterns,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createAuditWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['inventory', 'static-analysis', 'dependency-scan', 'secret-detection', 'vulnerability-check'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('audit', phase, topic, context);
-                const key = `audit/${Date.now()}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            // Extract potential vulnerabilities from patterns
-            const vulnerabilities = analysisResults.patterns.filter(p => p.includes('POTENTIAL SECRET') || p.includes('password') || p.includes('api_key'));
-            return {
-                status: 'complete',
-                data: {
-                    vulnerabilities,
-                    riskLevel: vulnerabilities.length > 0 ? 'medium' : 'low',
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createMapWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['file-discovery', 'import-analysis', 'graph-build', 'cycle-detection', 'layer-analysis'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('map', phase, topic, context);
-                const key = `map/${topic || 'full'}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    graph: { nodes: analysisResults.files.length },
-                    cycles: [],
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createPreloadWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['identify', 'fetch', 'cache'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('preload', phase, topic, context);
-                const key = `preload/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    preloaded: analysisResults.files.slice(0, 10),
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createDeepdiveWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['locate', 'trace-calls', 'build-graph', 'analyze-depth', 'summarize'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('deepdive', phase, topic, context);
-                const key = `deepdive/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    callGraph: { nodes: analysisResults.files.length },
-                    depth: 5,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createDocumentWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['analyze', 'template', 'generate', 'format'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('document', phase, topic, context);
-                const key = `document/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    documented: true,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createRefactorWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['complexity', 'duplication', 'coupling', 'suggestions'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('refactor', phase, topic, context);
-                const key = `refactor/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    suggestions: analysisResults.patterns.filter(p => p.includes('complexity')),
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createBenchmarkWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['discover', 'instrument', 'execute', 'analyze', 'report'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('benchmark', phase, topic, context);
-                const key = `benchmark/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            return {
-                status: 'complete',
-                data: {
-                    benchmarks: analysisResults.patterns,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    createTestgapsWorker() {
-        return async (context) => {
-            const { onProgress, onMemoryDeposit, signal, topic } = context;
-            const phases = ['coverage', 'paths', 'criticality', 'suggestions'];
-            const memoryKeys = [];
-            for (let i = 0; i < phases.length; i++) {
-                if (signal.aborted)
-                    throw new Error('Aborted');
-                const phase = phases[i];
-                onProgress(Math.round((i / phases.length) * 100), phase);
-                await this.executePhase('testgaps', phase, topic, context);
-                const key = `testgaps/${topic}/${phase}`;
-                memoryKeys.push(key);
-                onMemoryDeposit(key);
-            }
-            const analysisResults = this.phaseResults.get(context.workerId) || { files: [], patterns: [], bytes: 0 };
-            this.phaseResults.delete(context.workerId);
-            // Extract test-related patterns
-            const testPatterns = analysisResults.patterns.filter(p => p.includes('test'));
-            return {
-                status: 'complete',
-                data: {
-                    gaps: analysisResults.patterns.filter(p => !p.includes('test')),
-                    coverage: testPatterns.length > 0 ? (testPatterns.length / Math.max(1, analysisResults.files.length) * 100) : 0,
-                    files_analyzed: analysisResults.files.length,
-                    patterns_found: analysisResults.patterns.length,
-                    bytes_processed: analysisResults.bytes
-                },
-                completedPhases: phases.length,
-                totalPhases: phases.length,
-                memoryKeys,
-                duration: Date.now() - context.startTime
-            };
-        };
-    }
-    // Shared state for phase execution
-    phaseResults = new Map();
-    /**
-     * Execute a worker phase with REAL file analysis (pure JS, no native bindings)
-     */
-    async executePhase(worker, phase, topic, context) {
-        const fs = await import('fs/promises');
-        const path = await import('path');
-        const { glob } = await import('glob');
-        // Get or create phase results for this worker
-        const key = context.workerId;
-        if (!this.phaseResults.has(key)) {
-            this.phaseResults.set(key, { files: [], patterns: [], bytes: 0 });
-        }
-        const results = this.phaseResults.get(key);
-        // Dynamic phase execution with REAL operations
-        const executors = {
-            // Discovery phases - REAL file discovery
-            'discovery': async () => {
-                const pattern = topic
-                    ? `**/*${topic.replace(/[^a-zA-Z0-9]/g, '*')}*.{ts,js,tsx,jsx}`
-                    : '**/*.{ts,js,tsx,jsx}';
-                const files = await glob(pattern, {
-                    cwd: process.cwd(),
-                    ignore: ['node_modules/**', 'dist/**', '.git/**'],
-                    maxDepth: 5
-                });
-                results.files = files.slice(0, 100); // Limit to 100 files
-            },
-            'file-discovery': async () => {
-                const files = await glob('**/*.{ts,js,tsx,jsx}', {
-                    cwd: process.cwd(),
-                    ignore: ['node_modules/**', 'dist/**'],
-                    maxDepth: 4
-                });
-                results.files = files.slice(0, 100);
-            },
-            'inventory': async () => {
-                const files = await glob('**/*.{ts,js,tsx,jsx,json,md}', {
-                    cwd: process.cwd(),
-                    ignore: ['node_modules/**', 'dist/**'],
-                    maxDepth: 3
-                });
-                results.files = files.slice(0, 200);
-            },
-            'locate': async () => {
-                if (topic && results.files.length === 0) {
-                    const files = await glob(`**/*${topic}*.{ts,js}`, {
-                        cwd: process.cwd(),
-                        ignore: ['node_modules/**'],
-                        maxDepth: 5
-                    });
-                    results.files = files.slice(0, 50);
-                }
-            },
-            // Analysis phases - REAL file analysis
-            'analysis': async () => {
-                for (const file of results.files.slice(0, 20)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        results.bytes += content.length;
-                        // Extract patterns
-                        const patterns = this.extractPatterns(content, topic);
-                        results.patterns.push(...patterns);
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            'static-analysis': async () => {
-                for (const file of results.files.slice(0, 30)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        results.bytes += content.length;
-                        // Count functions, classes, exports
-                        const funcCount = (content.match(/function\s+\w+|=>\s*{|\(\)\s*{/g) || []).length;
-                        const classCount = (content.match(/class\s+\w+/g) || []).length;
-                        if (funcCount > 0)
-                            results.patterns.push(`${file}: ${funcCount} functions`);
-                        if (classCount > 0)
-                            results.patterns.push(`${file}: ${classCount} classes`);
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            'pattern-analysis': async () => {
-                for (const file of results.files.slice(0, 25)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        results.bytes += content.length;
-                        const patterns = this.extractPatterns(content, topic);
-                        results.patterns.push(...patterns);
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            'import-analysis': async () => {
-                for (const file of results.files.slice(0, 30)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        const imports = content.match(/import\s+.*from\s+['"][^'"]+['"]/g) || [];
-                        const requires = content.match(/require\s*\(\s*['"][^'"]+['"]\s*\)/g) || [];
-                        results.patterns.push(...imports.slice(0, 5), ...requires.slice(0, 5));
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            'complexity': async () => {
-                for (const file of results.files.slice(0, 15)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        const lines = content.split('\n').length;
-                        const ifCount = (content.match(/\bif\s*\(/g) || []).length;
-                        const loopCount = (content.match(/\b(for|while)\s*\(/g) || []).length;
-                        const complexity = ifCount + loopCount * 2;
-                        if (complexity > 10) {
-                            results.patterns.push(`${file}: complexity=${complexity} (${lines} lines)`);
-                        }
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            // Build phases - REAL graph building
-            'graph-build': async () => {
-                const graph = {};
-                for (const file of results.files.slice(0, 30)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        const imports = (content.match(/from\s+['"]\.\/[^'"]+['"]/g) || [])
-                            .map(i => i.replace(/from\s+['"]\.\//g, '').replace(/['"]/g, ''));
-                        graph[file] = imports;
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-                results.patterns.push(`Built dependency graph: ${Object.keys(graph).length} nodes`);
-            },
-            'trace-calls': async () => {
-                for (const file of results.files.slice(0, 20)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        const calls = content.match(/\w+\s*\([^)]*\)/g) || [];
-                        results.patterns.push(`${file}: ${calls.length} function calls`);
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            // Detection phases - REAL security scanning
-            'secret-detection': async () => {
-                const secretPatterns = [
-                    /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/gi,
-                    /password\s*[:=]\s*['"][^'"]+['"]/gi,
-                    /secret\s*[:=]\s*['"][^'"]+['"]/gi,
-                    /token\s*[:=]\s*['"][^'"]+['"]/gi
-                ];
-                for (const file of results.files.slice(0, 50)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        for (const pattern of secretPatterns) {
-                            const matches = content.match(pattern);
-                            if (matches) {
-                                results.patterns.push(`POTENTIAL SECRET in ${file}: ${matches.length} matches`);
-                            }
-                        }
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            'dependency-scan': async () => {
-                try {
-                    const pkgPath = path.join(process.cwd(), 'package.json');
-                    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
-                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-                    results.patterns.push(`Found ${Object.keys(deps).length} dependencies`);
-                    results.bytes += JSON.stringify(deps).length;
-                }
-                catch { /* no package.json */ }
-            },
-            // Test phases - REAL coverage analysis
-            'coverage': async () => {
-                const testFiles = await glob('**/*.{test,spec}.{ts,js,tsx,jsx}', {
-                    cwd: process.cwd(),
-                    ignore: ['node_modules/**']
-                });
-                results.patterns.push(`Found ${testFiles.length} test files`);
-                for (const file of testFiles.slice(0, 20)) {
-                    try {
-                        const content = await fs.readFile(path.join(process.cwd(), file), 'utf-8');
-                        const tests = (content.match(/\b(it|test|describe)\s*\(/g) || []).length;
-                        results.patterns.push(`${file}: ${tests} test cases`);
-                        results.bytes += content.length;
-                    }
-                    catch { /* file read error */ }
-                }
-            },
-            // Default for other phases
-            'vectorization': async () => { results.patterns.push('Vectorization complete (JS fallback)'); },
-            'indexing': async () => { results.patterns.push(`Indexed ${results.files.length} files`); },
-            'summarize': async () => { results.patterns.push(`Summary: ${results.patterns.length} patterns found`); },
-            'report': async () => { results.patterns.push('Report generated'); }
-        };
-        const executor = executors[phase];
-        if (executor) {
-            await executor();
-        }
-        else {
-            // Generic fallback - still do some work
-            await new Promise(r => setTimeout(r, 50));
-        }
-        // Store results in context for later retrieval
-        context.analysisResults = results;
-    }
-    /**
-     * Extract code patterns related to a topic
-     */
-    extractPatterns(content, topic) {
-        const patterns = [];
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            // Look for topic mentions
-            if (topic && line.toLowerCase().includes(topic.toLowerCase())) {
-                patterns.push(`Line ${i + 1}: ${line.trim().slice(0, 80)}`);
-            }
-            // Look for common patterns
-            if (line.match(/TODO|FIXME|HACK|XXX/i)) {
-                patterns.push(`TODO at line ${i + 1}: ${line.trim().slice(0, 60)}`);
-            }
-        }
-        return patterns.slice(0, 10); // Limit patterns per file
-    }
-    /**
-     * Get dashboard statistics including RuVector integration
-     */
-    getStats() {
-        const registryStats = this.registry.getStats();
-        const availability = this.governor.getAvailability();
-        const ruvectorStats = this.ruvector.getStats();
-        return {
-            active: availability.usedSlots,
-            byStatus: registryStats.byStatus,
-            byTrigger: registryStats.byTrigger,
-            availability,
-            ruvector: ruvectorStats
-        };
-    }
-    /**
-     * Get RuVector integration instance for advanced operations
-     */
-    getRuVectorIntegration() {
-        return this.ruvector;
-    }
-}
-// Singleton instance
-let instance = null;
-export function getWorkerDispatchService() {
-    if (!instance) {
-        instance = new WorkerDispatchService();
-    }
-    return instance;
-}
-//# sourceMappingURL=dispatch-service.js.map