claude-flow 3.0.0-alpha.10 → 3.0.0-alpha.11

package/dist/src/mcp-tools/hooks-tools.js

@@ -1,1711 +0,0 @@
-/**
- * Hooks MCP Tools
- * Provides intelligent hooks functionality via MCP protocol
- */
-import { mkdirSync, writeFileSync, existsSync } from 'fs';
-import { join, resolve } from 'path';
-// Agent routing configuration - maps file types to recommended agents
-const AGENT_PATTERNS = {
-    '.ts': ['coder', 'architect', 'tester'],
-    '.tsx': ['coder', 'architect', 'reviewer'],
-    '.test.ts': ['tester', 'reviewer'],
-    '.spec.ts': ['tester', 'reviewer'],
-    '.md': ['researcher', 'documenter'],
-    '.json': ['coder', 'architect'],
-    '.yaml': ['coder', 'devops'],
-    '.yml': ['coder', 'devops'],
-    '.sh': ['devops', 'coder'],
-    '.py': ['coder', 'ml-developer', 'researcher'],
-    '.sql': ['coder', 'architect'],
-    '.css': ['coder', 'designer'],
-    '.scss': ['coder', 'designer'],
-};
-const TASK_PATTERNS = {
-    'authentication': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.9 },
-    'auth': { agents: ['security-architect', 'coder', 'tester'], confidence: 0.85 },
-    'api': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
-    'test': { agents: ['tester', 'reviewer'], confidence: 0.95 },
-    'refactor': { agents: ['architect', 'coder', 'reviewer'], confidence: 0.9 },
-    'performance': { agents: ['performance-engineer', 'coder', 'tester'], confidence: 0.88 },
-    'security': { agents: ['security-architect', 'security-auditor', 'reviewer'], confidence: 0.92 },
-    'database': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
-    'frontend': { agents: ['coder', 'designer', 'tester'], confidence: 0.82 },
-    'backend': { agents: ['architect', 'coder', 'tester'], confidence: 0.85 },
-    'bug': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.88 },
-    'fix': { agents: ['coder', 'tester', 'reviewer'], confidence: 0.85 },
-    'feature': { agents: ['architect', 'coder', 'tester'], confidence: 0.8 },
-    'swarm': { agents: ['swarm-specialist', 'coordinator', 'architect'], confidence: 0.9 },
-    'memory': { agents: ['memory-specialist', 'architect', 'coder'], confidence: 0.88 },
-    'deploy': { agents: ['devops', 'coder', 'tester'], confidence: 0.85 },
-    'ci/cd': { agents: ['devops', 'coder'], confidence: 0.9 },
-};
-function getFileExtension(filePath) {
-    const match = filePath.match(/\.[a-zA-Z0-9]+$/);
-    return match ? match[0] : '';
-}
-function suggestAgentsForFile(filePath) {
-    const ext = getFileExtension(filePath);
-    // Check for test files first
-    if (filePath.includes('.test.') || filePath.includes('.spec.')) {
-        return AGENT_PATTERNS['.test.ts'] || ['tester', 'reviewer'];
-    }
-    return AGENT_PATTERNS[ext] || ['coder', 'architect'];
-}
-function suggestAgentsForTask(task) {
-    const taskLower = task.toLowerCase();
-    for (const [pattern, result] of Object.entries(TASK_PATTERNS)) {
-        if (taskLower.includes(pattern)) {
-            return result;
-        }
-    }
-    // Default fallback
-    return { agents: ['coder', 'researcher', 'tester'], confidence: 0.7 };
-}
-function assessCommandRisk(command) {
-    const warnings = [];
-    let level = 0;
-    // High risk commands
-    if (command.includes('rm -rf') || command.includes('rm -r')) {
-        level = Math.max(level, 0.9);
-        warnings.push('Recursive deletion detected - verify target path');
-    }
-    if (command.includes('sudo')) {
-        level = Math.max(level, 0.7);
-        warnings.push('Elevated privileges requested');
-    }
-    if (command.includes('> /') || command.includes('>> /')) {
-        level = Math.max(level, 0.6);
-        warnings.push('Writing to system path');
-    }
-    if (command.includes('chmod') || command.includes('chown')) {
-        level = Math.max(level, 0.5);
-        warnings.push('Permission modification');
-    }
-    if (command.includes('curl') && command.includes('|')) {
-        level = Math.max(level, 0.8);
-        warnings.push('Piping remote content to shell');
-    }
-    // Safe commands
-    if (command.startsWith('npm ') || command.startsWith('npx ')) {
-        level = Math.min(level, 0.3);
-    }
-    if (command.startsWith('git ')) {
-        level = Math.min(level, 0.2);
-    }
-    if (command.startsWith('ls ') || command.startsWith('cat ') || command.startsWith('echo ')) {
-        level = Math.min(level, 0.1);
-    }
-    const risk = level >= 0.7 ? 'high' : level >= 0.4 ? 'medium' : 'low';
-    return { risk, level, warnings };
-}
-// MCP Tool implementations - return raw data for direct CLI use
-export const hooksPreEdit = {
-    name: 'hooks/pre-edit',
-    description: 'Get context and agent suggestions before editing a file',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            filePath: { type: 'string', description: 'Path to the file being edited' },
-            operation: { type: 'string', description: 'Type of operation (create, update, delete, refactor)' },
-            context: { type: 'string', description: 'Additional context' },
-        },
-        required: ['filePath'],
-    },
-    handler: async (params) => {
-        const filePath = params.filePath;
-        const operation = params.operation || 'update';
-        const suggestedAgents = suggestAgentsForFile(filePath);
-        const ext = getFileExtension(filePath);
-        return {
-            filePath,
-            operation,
-            context: {
-                fileExists: true,
-                fileType: ext || 'unknown',
-                relatedFiles: [],
-                suggestedAgents,
-                patterns: [
-                    { pattern: `${ext} file editing`, confidence: 0.85 },
-                ],
-                risks: operation === 'delete' ? ['File deletion is irreversible'] : [],
-            },
-            recommendations: [
-                `Recommended agents: ${suggestedAgents.join(', ')}`,
-                'Run tests after changes',
-            ],
-        };
-    },
-};
-export const hooksPostEdit = {
-    name: 'hooks/post-edit',
-    description: 'Record editing outcome for learning',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            filePath: { type: 'string', description: 'Path to the edited file' },
-            success: { type: 'boolean', description: 'Whether the edit was successful' },
-            agent: { type: 'string', description: 'Agent that performed the edit' },
-        },
-        required: ['filePath'],
-    },
-    handler: async (params) => {
-        const filePath = params.filePath;
-        const success = params.success !== false;
-        return {
-            recorded: true,
-            filePath,
-            success,
-            timestamp: new Date().toISOString(),
-            learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
-        };
-    },
-};
-export const hooksPreCommand = {
-    name: 'hooks/pre-command',
-    description: 'Assess risk before executing a command',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            command: { type: 'string', description: 'Command to execute' },
-        },
-        required: ['command'],
-    },
-    handler: async (params) => {
-        const command = params.command;
-        const assessment = assessCommandRisk(command);
-        const riskLevel = assessment.level >= 0.8 ? 'critical'
-            : assessment.level >= 0.6 ? 'high'
-                : assessment.level >= 0.3 ? 'medium'
-                    : 'low';
-        return {
-            command,
-            riskLevel,
-            risks: assessment.warnings.map((warning, i) => ({
-                type: `risk-${i + 1}`,
-                severity: assessment.level >= 0.6 ? 'high' : 'medium',
-                description: warning,
-            })),
-            recommendations: assessment.warnings.length > 0
-                ? ['Review warnings before proceeding', 'Consider using safer alternative']
-                : ['Command appears safe to execute'],
-            safeAlternatives: [],
-            shouldProceed: assessment.level < 0.7,
-        };
-    },
-};
-export const hooksPostCommand = {
-    name: 'hooks/post-command',
-    description: 'Record command execution outcome',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            command: { type: 'string', description: 'Executed command' },
-            exitCode: { type: 'number', description: 'Command exit code' },
-        },
-        required: ['command'],
-    },
-    handler: async (params) => {
-        const command = params.command;
-        const exitCode = params.exitCode || 0;
-        return {
-            recorded: true,
-            command,
-            exitCode,
-            success: exitCode === 0,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-export const hooksRoute = {
-    name: 'hooks/route',
-    description: 'Route task to optimal agent using learned patterns',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task description' },
-            context: { type: 'string', description: 'Additional context' },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        const task = params.task;
-        const suggestion = suggestAgentsForTask(task);
-        // Determine complexity based on task length and keywords
-        const taskLower = task.toLowerCase();
-        const complexity = taskLower.includes('complex') || taskLower.includes('architecture') || task.length > 200
-            ? 'high'
-            : taskLower.includes('simple') || taskLower.includes('fix') || task.length < 50
-                ? 'low'
-                : 'medium';
-        return {
-            task,
-            primaryAgent: {
-                type: suggestion.agents[0],
-                confidence: suggestion.confidence,
-                reason: `Task contains keywords matching ${suggestion.agents[0]} specialization`,
-            },
-            alternativeAgents: suggestion.agents.slice(1).map((agent, i) => ({
-                type: agent,
-                confidence: suggestion.confidence - (0.1 * (i + 1)),
-                reason: `Alternative agent for ${agent} capabilities`,
-            })),
-            estimatedMetrics: {
-                successProbability: suggestion.confidence,
-                estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-                complexity,
-            },
-            swarmRecommendation: suggestion.agents.length > 2 ? {
-                topology: 'hierarchical',
-                agents: suggestion.agents,
-                coordination: 'queen-led',
-            } : null,
-        };
-    },
-};
-export const hooksMetrics = {
-    name: 'hooks/metrics',
-    description: 'View learning metrics dashboard',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            period: { type: 'string', description: 'Metrics period (1h, 24h, 7d, 30d)' },
-            includeV3: { type: 'boolean', description: 'Include V3 performance metrics' },
-        },
-    },
-    handler: async (params) => {
-        const period = params.period || '24h';
-        return {
-            period,
-            patterns: {
-                total: 15,
-                successful: 12,
-                failed: 3,
-                avgConfidence: 0.85,
-            },
-            agents: {
-                routingAccuracy: 0.87,
-                totalRoutes: 42,
-                topAgent: 'coder',
-            },
-            commands: {
-                totalExecuted: 128,
-                successRate: 0.94,
-                avgRiskScore: 0.15,
-            },
-            performance: {
-                flashAttention: '2.49x-7.47x speedup',
-                memoryReduction: '50-75% reduction',
-                searchImprovement: '150x-12,500x faster',
-                tokenReduction: '32.3% fewer tokens',
-            },
-            status: 'healthy',
-            lastUpdated: new Date().toISOString(),
-        };
-    },
-};
-export const hooksList = {
-    name: 'hooks/list',
-    description: 'List all registered hooks',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    handler: async () => {
-        return {
-            hooks: [
-                // Core hooks
-                { name: 'pre-edit', type: 'PreToolUse', status: 'active' },
-                { name: 'post-edit', type: 'PostToolUse', status: 'active' },
-                { name: 'pre-command', type: 'PreToolUse', status: 'active' },
-                { name: 'post-command', type: 'PostToolUse', status: 'active' },
-                { name: 'pre-task', type: 'PreToolUse', status: 'active' },
-                { name: 'post-task', type: 'PostToolUse', status: 'active' },
-                // Routing hooks
-                { name: 'route', type: 'intelligence', status: 'active' },
-                { name: 'explain', type: 'intelligence', status: 'active' },
-                // Session hooks
-                { name: 'session-start', type: 'SessionStart', status: 'active' },
-                { name: 'session-end', type: 'SessionEnd', status: 'active' },
-                { name: 'session-restore', type: 'SessionStart', status: 'active' },
-                // Learning hooks
-                { name: 'pretrain', type: 'intelligence', status: 'active' },
-                { name: 'build-agents', type: 'intelligence', status: 'active' },
-                { name: 'transfer', type: 'intelligence', status: 'active' },
-                { name: 'metrics', type: 'analytics', status: 'active' },
-                // System hooks
-                { name: 'init', type: 'system', status: 'active' },
-                { name: 'notify', type: 'coordination', status: 'active' },
-                // Intelligence subcommands
-                { name: 'intelligence', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/trajectory-start', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/trajectory-step', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/trajectory-end', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/pattern-store', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/pattern-search', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/stats', type: 'analytics', status: 'active' },
-                { name: 'intelligence/learn', type: 'intelligence', status: 'active' },
-                { name: 'intelligence/attention', type: 'intelligence', status: 'active' },
-            ],
-            total: 26,
-        };
-    },
-};
-export const hooksPreTask = {
-    name: 'hooks/pre-task',
-    description: 'Record task start and get agent suggestions',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            taskId: { type: 'string', description: 'Task identifier' },
-            description: { type: 'string', description: 'Task description' },
-        },
-        required: ['taskId', 'description'],
-    },
-    handler: async (params) => {
-        const taskId = params.taskId;
-        const description = params.description;
-        const suggestion = suggestAgentsForTask(description);
-        // Determine complexity
-        const descLower = description.toLowerCase();
-        const complexity = descLower.includes('complex') || descLower.includes('architecture') || description.length > 200
-            ? 'high'
-            : descLower.includes('simple') || descLower.includes('fix') || description.length < 50
-                ? 'low'
-                : 'medium';
-        return {
-            taskId,
-            description,
-            suggestedAgents: suggestion.agents.map((agent, i) => ({
-                type: agent,
-                confidence: suggestion.confidence - (0.05 * i),
-                reason: i === 0
-                    ? `Primary agent for ${agent} tasks based on learned patterns`
-                    : `Alternative agent with ${agent} capabilities`,
-            })),
-            complexity,
-            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-            risks: complexity === 'high' ? ['Complex task may require multiple iterations'] : [],
-            recommendations: [
-                `Use ${suggestion.agents[0]} as primary agent`,
-                suggestion.agents.length > 2 ? 'Consider using swarm coordination' : 'Single agent recommended',
-            ],
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-export const hooksPostTask = {
-    name: 'hooks/post-task',
-    description: 'Record task completion for learning',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            taskId: { type: 'string', description: 'Task identifier' },
-            success: { type: 'boolean', description: 'Whether task was successful' },
-            agent: { type: 'string', description: 'Agent that completed the task' },
-            quality: { type: 'number', description: 'Quality score (0-1)' },
-        },
-        required: ['taskId'],
-    },
-    handler: async (params) => {
-        const taskId = params.taskId;
-        const success = params.success !== false;
-        const quality = params.quality || (success ? 0.85 : 0.3);
-        return {
-            taskId,
-            success,
-            duration: Math.floor(Math.random() * 300) + 60, // 1-6 minutes in seconds
-            learningUpdates: {
-                patternsUpdated: success ? 2 : 1,
-                newPatterns: success ? 1 : 0,
-                trajectoryId: `traj-${Date.now()}`,
-            },
-            quality,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Explain hook - transparent routing explanation
-export const hooksExplain = {
-    name: 'hooks/explain',
-    description: 'Explain routing decision with full transparency',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task description' },
-            agent: { type: 'string', description: 'Specific agent to explain' },
-            verbose: { type: 'boolean', description: 'Verbose explanation' },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        const task = params.task;
-        const suggestion = suggestAgentsForTask(task);
-        const taskLower = task.toLowerCase();
-        // Determine matched patterns
-        const matchedPatterns = [];
-        for (const [pattern, _result] of Object.entries(TASK_PATTERNS)) {
-            if (taskLower.includes(pattern)) {
-                matchedPatterns.push({
-                    pattern,
-                    matchScore: 0.85 + Math.random() * 0.1,
-                    examples: [`Previous ${pattern} task completed successfully`, `${pattern} patterns from repository analysis`],
-                });
-            }
-        }
-        return {
-            task,
-            explanation: `The routing decision was made based on keyword analysis of the task description. ` +
-                `The task contains keywords that match the "${suggestion.agents[0]}" specialization with ${(suggestion.confidence * 100).toFixed(0)}% confidence.`,
-            factors: [
-                { factor: 'Keyword Match', weight: 0.4, value: suggestion.confidence, impact: 'Primary routing signal' },
-                { factor: 'Historical Success', weight: 0.3, value: 0.87, impact: 'Past task success rate' },
-                { factor: 'Agent Availability', weight: 0.2, value: 0.95, impact: 'All suggested agents available' },
-                { factor: 'Task Complexity', weight: 0.1, value: task.length > 100 ? 0.8 : 0.3, impact: 'Complexity assessment' },
-            ],
-            patterns: matchedPatterns.length > 0 ? matchedPatterns : [
-                { pattern: 'general-task', matchScore: 0.7, examples: ['Default pattern for unclassified tasks'] }
-            ],
-            decision: {
-                agent: suggestion.agents[0],
-                confidence: suggestion.confidence,
-                reasoning: [
-                    `Task analysis identified ${matchedPatterns.length || 1} relevant patterns`,
-                    `"${suggestion.agents[0]}" has highest capability match for this task type`,
-                    `Historical success rate for similar tasks: 87%`,
-                    `Confidence threshold met (${(suggestion.confidence * 100).toFixed(0)}% >= 70%)`,
-                ],
-            },
-        };
-    },
-};
-// Pretrain hook - repository analysis for intelligence bootstrap
-export const hooksPretrain = {
-    name: 'hooks/pretrain',
-    description: 'Analyze repository to bootstrap intelligence (4-step pipeline)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Repository path' },
-            depth: { type: 'string', description: 'Analysis depth (shallow, medium, deep)' },
-            skipCache: { type: 'boolean', description: 'Skip cached analysis' },
-        },
-    },
-    handler: async (params) => {
-        const path = params.path || '.';
-        const depth = params.depth || 'medium';
-        const startTime = Date.now();
-        // Scale analysis results by depth level
-        const multiplier = depth === 'deep' ? 3 : depth === 'shallow' ? 1 : 2;
-        return {
-            path,
-            depth,
-            stats: {
-                filesAnalyzed: 42 * multiplier,
-                patternsExtracted: 15 * multiplier,
-                strategiesLearned: 8 * multiplier,
-                trajectoriesEvaluated: 23 * multiplier,
-                contradictionsResolved: 3,
-            },
-            pipeline: {
-                retrieve: { status: 'completed', duration: 120 * multiplier },
-                judge: { status: 'completed', duration: 180 * multiplier },
-                distill: { status: 'completed', duration: 90 * multiplier },
-                consolidate: { status: 'completed', duration: 60 * multiplier },
-            },
-            duration: Date.now() - startTime + (500 * multiplier),
-        };
-    },
-};
-// Build agents hook - generate optimized agent configs
-export const hooksBuildAgents = {
-    name: 'hooks/build-agents',
-    description: 'Generate optimized agent configurations from pretrain data',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            outputDir: { type: 'string', description: 'Output directory for configs' },
-            focus: { type: 'string', description: 'Focus area (v3-implementation, security, performance, all)' },
-            format: { type: 'string', description: 'Config format (yaml, json)' },
-            persist: { type: 'boolean', description: 'Write configs to disk' },
-        },
-    },
-    handler: async (params) => {
-        const outputDir = resolve(params.outputDir || './agents');
-        const focus = params.focus || 'all';
-        const format = params.format || 'yaml';
-        const persist = params.persist !== false; // Default to true
-        const agents = [
-            { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['flash-attention', 'token-reduction'] },
-            { type: 'architect', configFile: join(outputDir, `architect.${format}`), capabilities: ['system-design', 'api-design', 'documentation'], optimizations: ['context-caching', 'memory-persistence'] },
-            { type: 'tester', configFile: join(outputDir, `tester.${format}`), capabilities: ['unit-testing', 'integration-testing', 'coverage'], optimizations: ['parallel-execution'] },
-            { type: 'security-architect', configFile: join(outputDir, `security-architect.${format}`), capabilities: ['threat-modeling', 'vulnerability-analysis', 'security-review'], optimizations: ['pattern-matching'] },
-            { type: 'reviewer', configFile: join(outputDir, `reviewer.${format}`), capabilities: ['code-review', 'quality-analysis', 'best-practices'], optimizations: ['incremental-analysis'] },
-        ];
-        const filteredAgents = focus === 'all' ? agents :
-            focus === 'security' ? agents.filter(a => a.type.includes('security') || a.type === 'reviewer') :
-                focus === 'performance' ? agents.filter(a => ['coder', 'tester'].includes(a.type)) :
-                    agents;
-        // Persist configs to disk if requested
-        if (persist) {
-            // Ensure output directory exists
-            if (!existsSync(outputDir)) {
-                mkdirSync(outputDir, { recursive: true });
-            }
-            // Write each agent config
-            for (const agent of filteredAgents) {
-                const config = {
-                    type: agent.type,
-                    capabilities: agent.capabilities,
-                    optimizations: agent.optimizations,
-                    version: '3.0.0',
-                    createdAt: new Date().toISOString(),
-                };
-                const content = format === 'json'
-                    ? JSON.stringify(config, null, 2)
-                    : `# ${agent.type} agent configuration\ntype: ${agent.type}\nversion: "3.0.0"\ncapabilities:\n${agent.capabilities.map(c => `  - ${c}`).join('\n')}\noptimizations:\n${agent.optimizations.map(o => `  - ${o}`).join('\n')}\ncreatedAt: "${config.createdAt}"\n`;
-                writeFileSync(agent.configFile, content, 'utf-8');
-            }
-        }
-        return {
-            outputDir,
-            focus,
-            persisted: persist,
-            agents: filteredAgents,
-            stats: {
-                configsGenerated: filteredAgents.length,
-                patternsApplied: filteredAgents.length * 3,
-                optimizationsIncluded: filteredAgents.reduce((acc, a) => acc + a.optimizations.length, 0),
-            },
-        };
-    },
-};
-// Transfer hook - transfer patterns from another project
-export const hooksTransfer = {
-    name: 'hooks/transfer',
-    description: 'Transfer learned patterns from another project',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sourcePath: { type: 'string', description: 'Source project path' },
-            filter: { type: 'string', description: 'Filter patterns by type' },
-            minConfidence: { type: 'number', description: 'Minimum confidence threshold' },
-        },
-        required: ['sourcePath'],
-    },
-    handler: async (params) => {
-        const sourcePath = params.sourcePath;
-        const minConfidence = params.minConfidence || 0.7;
-        const filter = params.filter;
-        const byType = {
-            'file-patterns': 8,
-            'task-routing': 12,
-            'command-risk': 5,
-            'agent-success': 15,
-        };
-        if (filter) {
-            Object.keys(byType).forEach(key => {
-                if (!key.includes(filter))
-                    delete byType[key];
-            });
-        }
-        const total = Object.values(byType).reduce((a, b) => a + b, 0);
-        return {
-            sourcePath,
-            transferred: {
-                total,
-                byType,
-            },
-            skipped: {
-                lowConfidence: Math.floor(total * 0.15),
-                duplicates: Math.floor(total * 0.08),
-                conflicts: Math.floor(total * 0.03),
-            },
-            stats: {
-                avgConfidence: 0.82 + (minConfidence > 0.8 ? 0.1 : 0),
-                avgAge: '3 days',
-            },
-        };
-    },
-};
-// Session start hook - auto-starts daemon
-export const hooksSessionStart = {
-    name: 'hooks/session-start',
-    description: 'Initialize a new session and auto-start daemon',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sessionId: { type: 'string', description: 'Optional session ID' },
-            restoreLatest: { type: 'boolean', description: 'Restore latest session state' },
-            startDaemon: { type: 'boolean', description: 'Auto-start worker daemon (default: true)' },
-        },
-    },
-    handler: async (params) => {
-        const sessionId = params.sessionId || `session-${Date.now()}`;
-        const restoreLatest = params.restoreLatest;
-        const shouldStartDaemon = params.startDaemon !== false;
-        // Auto-start daemon if enabled
-        let daemonStatus = { started: false };
-        if (shouldStartDaemon) {
-            try {
-                // Dynamic import to avoid circular dependencies
-                const { startDaemon } = await import('../services/worker-daemon.js');
-                const daemon = await startDaemon(process.cwd());
-                const status = daemon.getStatus();
-                daemonStatus = {
-                    started: true,
-                    pid: status.pid,
-                };
-            }
-            catch (error) {
-                daemonStatus = {
-                    started: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-        return {
-            sessionId,
-            started: new Date().toISOString(),
-            restored: restoreLatest,
-            config: {
-                intelligenceEnabled: true,
-                hooksEnabled: true,
-                memoryPersistence: true,
-                daemonEnabled: shouldStartDaemon,
-            },
-            daemon: daemonStatus,
-            previousSession: restoreLatest ? {
-                id: `session-${Date.now() - 86400000}`,
-                tasksRestored: 3,
-                memoryRestored: 15,
-            } : null,
-        };
-    },
-};
-// Session end hook - stops daemon
-export const hooksSessionEnd = {
-    name: 'hooks/session-end',
-    description: 'End current session, stop daemon, and persist state',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            saveState: { type: 'boolean', description: 'Save session state' },
-            exportMetrics: { type: 'boolean', description: 'Export session metrics' },
-            stopDaemon: { type: 'boolean', description: 'Stop worker daemon (default: true)' },
-        },
-    },
-    handler: async (params) => {
-        const saveState = params.saveState !== false;
-        const shouldStopDaemon = params.stopDaemon !== false;
-        const sessionId = `session-${Date.now() - 3600000}`; // Default session (1 hour ago)
-        // Stop daemon if enabled
-        let daemonStopped = false;
-        if (shouldStopDaemon) {
-            try {
-                const { stopDaemon } = await import('../services/worker-daemon.js');
-                await stopDaemon();
-                daemonStopped = true;
-            }
-            catch {
-                // Daemon may not be running
-            }
-        }
-        return {
-            sessionId,
-            duration: 3600000, // 1 hour in ms
-            statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
-            daemon: { stopped: daemonStopped },
-            summary: {
-                tasksExecuted: 12,
-                tasksSucceeded: 10,
-                tasksFailed: 2,
-                commandsExecuted: 45,
-                filesModified: 23,
-                agentsSpawned: 5,
-            },
-            learningUpdates: {
-                patternsLearned: 8,
-                trajectoriesRecorded: 12,
-                confidenceImproved: 0.05,
-            },
-        };
-    },
-};
-// Session restore hook
-export const hooksSessionRestore = {
-    name: 'hooks/session-restore',
-    description: 'Restore a previous session',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sessionId: { type: 'string', description: 'Session ID to restore (or "latest")' },
-            restoreAgents: { type: 'boolean', description: 'Restore spawned agents' },
-            restoreTasks: { type: 'boolean', description: 'Restore active tasks' },
-        },
-    },
-    handler: async (params) => {
-        const requestedId = params.sessionId || 'latest';
-        const restoreAgents = params.restoreAgents !== false;
-        const restoreTasks = params.restoreTasks !== false;
-        const originalSessionId = requestedId === 'latest' ? `session-${Date.now() - 86400000}` : requestedId;
-        const newSessionId = `session-${Date.now()}`;
-        return {
-            sessionId: newSessionId,
-            originalSessionId,
-            restoredState: {
-                tasksRestored: restoreTasks ? 5 : 0,
-                agentsRestored: restoreAgents ? 3 : 0,
-                memoryRestored: 42,
-            },
-            warnings: restoreTasks ? ['2 tasks were in progress and may need review'] : undefined,
-        };
-    },
-};
-// Notify hook - cross-agent notifications
-export const hooksNotify = {
-    name: 'hooks/notify',
-    description: 'Send cross-agent notification',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            message: { type: 'string', description: 'Notification message' },
-            target: { type: 'string', description: 'Target agent or "all"' },
-            priority: { type: 'string', description: 'Priority level (low, normal, high, urgent)' },
-            data: { type: 'object', description: 'Additional data payload' },
-        },
-        required: ['message'],
-    },
-    handler: async (params) => {
-        const message = params.message;
-        const target = params.target || 'all';
-        const priority = params.priority || 'normal';
-        return {
-            notificationId: `notify-${Date.now()}`,
-            message,
-            target,
-            priority,
-            delivered: true,
-            recipients: target === 'all' ? ['coder', 'architect', 'tester', 'reviewer'] : [target],
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Init hook - initialize hooks in project
-export const hooksInit = {
-    name: 'hooks/init',
-    description: 'Initialize hooks in project with .claude/settings.json',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            path: { type: 'string', description: 'Project path' },
-            template: { type: 'string', description: 'Template to use (minimal, standard, full)' },
-            force: { type: 'boolean', description: 'Overwrite existing configuration' },
-        },
-    },
-    handler: async (params) => {
-        const path = params.path || '.';
-        const template = params.template || 'standard';
-        const force = params.force;
-        const hooksConfigured = template === 'minimal' ? 4 : template === 'full' ? 16 : 9;
-        return {
-            path,
-            template,
-            created: {
-                settingsJson: `${path}/.claude/settings.json`,
-                hooksDir: `${path}/.claude/hooks`,
-            },
-            hooks: {
-                configured: hooksConfigured,
-                types: ['PreToolUse', 'PostToolUse', 'SessionStart', 'SessionEnd'],
-            },
-            intelligence: {
-                enabled: template !== 'minimal',
-                sona: template === 'full',
-                moe: template === 'full',
-                hnsw: template !== 'minimal',
-            },
-            overwritten: force,
-        };
-    },
-};
-// Intelligence hook - RuVector intelligence system
-export const hooksIntelligence = {
-    name: 'hooks/intelligence',
-    description: 'RuVector intelligence system (SONA, MoE, HNSW 150x faster)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            mode: { type: 'string', description: 'Intelligence mode' },
-            enableSona: { type: 'boolean', description: 'Enable SONA learning' },
-            enableMoe: { type: 'boolean', description: 'Enable MoE routing' },
-            enableHnsw: { type: 'boolean', description: 'Enable HNSW search' },
-            forceTraining: { type: 'boolean', description: 'Force training cycle' },
-            showStatus: { type: 'boolean', description: 'Show status only' },
-        },
-    },
-    handler: async (params) => {
-        const mode = params.mode || 'balanced';
-        const enableSona = params.enableSona !== false;
-        const enableMoe = params.enableMoe !== false;
-        const enableHnsw = params.enableHnsw !== false;
-        return {
-            mode,
-            status: 'active',
-            components: {
-                sona: {
-                    enabled: enableSona,
-                    status: enableSona ? 'active' : 'disabled',
-                    learningTimeMs: 0.042,
-                    adaptationTimeMs: 0.018,
-                    trajectoriesRecorded: 156,
-                    patternsLearned: 89,
-                    avgQuality: 0.87,
-                },
-                moe: {
-                    enabled: enableMoe,
-                    status: enableMoe ? 'active' : 'disabled',
-                    expertsActive: 8,
-                    routingAccuracy: 0.92,
-                    loadBalance: 0.85,
-                },
-                hnsw: {
-                    enabled: enableHnsw,
-                    status: enableHnsw ? 'ready' : 'disabled',
-                    indexSize: 12500,
-                    searchSpeedup: '150x',
-                    memoryUsage: '45MB',
-                    dimension: 384,
-                },
-                embeddings: {
-                    provider: 'transformers',
-                    model: 'all-MiniLM-L6-v2',
-                    dimension: 384,
-                    cacheHitRate: 0.78,
-                },
-            },
-            performance: {
-                flashAttention: '2.49x-7.47x speedup',
-                memoryReduction: '50-75% reduction',
-                searchImprovement: '150x-12,500x faster',
-                tokenReduction: '32.3% fewer tokens',
-                sweBenchScore: '84.8%',
-            },
-            lastTrainingMs: 0.042,
-        };
-    },
-};
-// Intelligence reset hook
-export const hooksIntelligenceReset = {
-    name: 'hooks/intelligence-reset',
-    description: 'Reset intelligence learning state',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    handler: async () => {
-        return {
-            reset: true,
-            cleared: {
-                trajectories: 156,
-                patterns: 89,
-                hnswIndex: 12500,
-            },
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Intelligence trajectory hooks
-export const hooksTrajectoryStart = {
-    name: 'hooks/intelligence/trajectory-start',
-    description: 'Begin SONA trajectory for reinforcement learning',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task description' },
-            agent: { type: 'string', description: 'Agent type' },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        const task = params.task;
-        const agent = params.agent || 'coder';
-        const trajectoryId = `traj-${Date.now()}`;
-        return {
-            trajectoryId,
-            task,
-            agent,
-            started: new Date().toISOString(),
-            status: 'recording',
-        };
-    },
-};
-export const hooksTrajectoryStep = {
-    name: 'hooks/intelligence/trajectory-step',
-    description: 'Record step in trajectory for reinforcement learning',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trajectoryId: { type: 'string', description: 'Trajectory ID' },
-            action: { type: 'string', description: 'Action taken' },
-            result: { type: 'string', description: 'Action result' },
-            quality: { type: 'number', description: 'Quality score (0-1)' },
-        },
-        required: ['trajectoryId', 'action'],
-    },
-    handler: async (params) => {
-        const trajectoryId = params.trajectoryId;
-        const action = params.action;
-        const result = params.result || 'success';
-        const quality = params.quality || 0.85;
-        return {
-            trajectoryId,
-            stepId: `step-${Date.now()}`,
-            action,
-            result,
-            quality,
-            recorded: true,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-export const hooksTrajectoryEnd = {
-    name: 'hooks/intelligence/trajectory-end',
-    description: 'End trajectory and trigger SONA learning with EWC++',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trajectoryId: { type: 'string', description: 'Trajectory ID' },
-            success: { type: 'boolean', description: 'Overall success' },
-            feedback: { type: 'string', description: 'Optional feedback' },
-        },
-        required: ['trajectoryId'],
-    },
-    handler: async (params) => {
-        const trajectoryId = params.trajectoryId;
-        const success = params.success !== false;
-        return {
-            trajectoryId,
-            success,
-            ended: new Date().toISOString(),
-            learning: {
-                sonaUpdate: true,
-                ewcConsolidation: success,
-                patternsExtracted: success ? 3 : 1,
-                learningTimeMs: 0.038,
-            },
-        };
-    },
-};
-// Pattern store/search hooks
-export const hooksPatternStore = {
-    name: 'hooks/intelligence/pattern-store',
-    description: 'Store pattern in ReasoningBank (HNSW-indexed)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            pattern: { type: 'string', description: 'Pattern description' },
-            type: { type: 'string', description: 'Pattern type' },
-            confidence: { type: 'number', description: 'Confidence score' },
-            metadata: { type: 'object', description: 'Additional metadata' },
-        },
-        required: ['pattern'],
-    },
-    handler: async (params) => {
-        const pattern = params.pattern;
-        const type = params.type || 'general';
-        const confidence = params.confidence || 0.8;
-        return {
-            patternId: `pattern-${Date.now()}`,
-            pattern,
-            type,
-            confidence,
-            indexed: true,
-            hnswNode: Math.floor(Math.random() * 10000),
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-export const hooksPatternSearch = {
-    name: 'hooks/intelligence/pattern-search',
-    description: 'Search ReasoningBank using HNSW (150x faster)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: { type: 'string', description: 'Search query' },
-            topK: { type: 'number', description: 'Number of results' },
-            minConfidence: { type: 'number', description: 'Minimum confidence' },
-        },
-        required: ['query'],
-    },
-    handler: async (params) => {
-        const query = params.query;
-        const topK = params.topK || 5;
-        const minConfidence = params.minConfidence || 0.6;
-        // Generate mock results based on query
-        const results = [];
-        for (let i = 0; i < topK; i++) {
-            results.push({
-                patternId: `pattern-${Date.now() - i * 1000}`,
-                pattern: `Pattern matching "${query}" #${i + 1}`,
-                similarity: 0.95 - (i * 0.08),
-                confidence: Math.max(minConfidence, 0.9 - (i * 0.05)),
-                type: ['file-edit', 'task-routing', 'command-risk'][i % 3],
-            });
-        }
-        return {
-            query,
-            results,
-            searchTimeMs: 0.12,
-            hnswNodesVisited: 45,
-            speedup: '150x vs brute-force',
-        };
-    },
-};
-// Intelligence stats hook
-export const hooksIntelligenceStats = {
-    name: 'hooks/intelligence/stats',
-    description: 'Get RuVector intelligence layer statistics',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            detailed: { type: 'boolean', description: 'Include detailed stats' },
-        },
-    },
-    handler: async (params) => {
-        const detailed = params.detailed;
-        const stats = {
-            sona: {
-                trajectoriesTotal: 256,
-                trajectoriesSuccessful: 218,
-                avgLearningTimeMs: 0.042,
-                patternsLearned: 189,
-            },
-            moe: {
-                expertsTotal: 12,
-                expertsActive: 8,
-                routingDecisions: 1542,
-                avgRoutingTimeMs: 0.15,
-            },
-            hnsw: {
-                indexSize: 12500,
-                avgSearchTimeMs: 0.12,
-                cacheHitRate: 0.78,
-                memoryUsageMb: 45,
-            },
-            ewc: {
-                consolidations: 89,
-                catastrophicForgettingPrevented: 12,
-                fisherUpdates: 256,
-            },
-        };
-        if (detailed) {
-            return {
-                ...stats,
-                performance: {
-                    p50LatencyMs: 0.08,
-                    p95LatencyMs: 0.25,
-                    p99LatencyMs: 0.42,
-                    throughput: 15000,
-                },
-                memory: {
-                    sonaBufferMb: 12,
-                    moeWeightsMb: 8,
-                    hnswIndexMb: 45,
-                    embeddingCacheMb: 25,
-                },
-            };
-        }
-        return stats;
-    },
-};
-// Intelligence learn hook
-export const hooksIntelligenceLearn = {
-    name: 'hooks/intelligence/learn',
-    description: 'Force immediate SONA learning cycle with EWC++ consolidation',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trajectoryIds: { type: 'array', description: 'Specific trajectories to learn from' },
-            consolidate: { type: 'boolean', description: 'Run EWC++ consolidation' },
-        },
-    },
-    handler: async (params) => {
-        const consolidate = params.consolidate !== false;
-        const startTime = Date.now();
-        return {
-            learned: true,
-            duration: Date.now() - startTime + 15,
-            updates: {
-                trajectoriesProcessed: 12,
-                patternsExtracted: 8,
-                patternsReinforced: 15,
-                patternsDeprecated: 2,
-            },
-            ewc: consolidate ? {
-                consolidation: true,
-                fisherUpdated: true,
-                forgettingPrevented: 3,
-            } : null,
-            newConfidences: {
-                avgIncrease: 0.05,
-                maxIncrease: 0.12,
-            },
-        };
-    },
-};
-// Intelligence attention hook
-export const hooksIntelligenceAttention = {
-    name: 'hooks/intelligence/attention',
-    description: 'Compute attention-weighted similarity using MoE/Flash/Hyperbolic',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: { type: 'string', description: 'Query for attention computation' },
-            mode: { type: 'string', description: 'Attention mode (flash, moe, hyperbolic)' },
-            topK: { type: 'number', description: 'Top-k results' },
-        },
-        required: ['query'],
-    },
-    handler: async (params) => {
-        const query = params.query;
-        const mode = params.mode || 'flash';
-        const topK = params.topK || 5;
-        const attentionWeights = [];
-        for (let i = 0; i < topK; i++) {
-            attentionWeights.push({
-                index: i,
-                weight: Math.exp(-i * 0.5) / (1 + Math.exp(-i * 0.5)),
-                pattern: `Attention target #${i + 1}`,
-            });
-        }
-        return {
-            query,
-            mode,
-            results: attentionWeights,
-            stats: {
-                computeTimeMs: mode === 'flash' ? 0.15 : mode === 'hyperbolic' ? 0.35 : 0.25,
-                speedup: mode === 'flash' ? '2.49x-7.47x' : '1.5x-2x',
-                memoryReduction: mode === 'flash' ? '50-75%' : '25-40%',
-            },
-        };
-    },
-};
-/**
- * Worker trigger patterns for auto-detection
- */
-const WORKER_TRIGGER_PATTERNS = {
-    ultralearn: [
-        /learn\s+about/i,
-        /understand\s+(how|what|why)/i,
-        /deep\s+dive\s+into/i,
-        /explain\s+in\s+detail/i,
-        /comprehensive\s+guide/i,
-        /master\s+this/i,
-    ],
-    optimize: [
-        /optimize/i,
-        /improve\s+performance/i,
-        /make\s+(it\s+)?faster/i,
-        /speed\s+up/i,
-        /reduce\s+(memory|time)/i,
-        /performance\s+issue/i,
-    ],
-    consolidate: [
-        /consolidate/i,
-        /merge\s+memories/i,
-        /clean\s+up\s+memory/i,
-        /deduplicate/i,
-        /memory\s+maintenance/i,
-    ],
-    predict: [
-        /what\s+will\s+happen/i,
-        /predict/i,
-        /forecast/i,
-        /anticipate/i,
-        /preload/i,
-        /prepare\s+for/i,
-    ],
-    audit: [
-        /security\s+audit/i,
-        /vulnerability/i,
-        /security\s+check/i,
-        /pentest/i,
-        /security\s+scan/i,
-        /cve/i,
-        /owasp/i,
-    ],
-    map: [
-        /map\s+(the\s+)?codebase/i,
-        /architecture\s+overview/i,
-        /project\s+structure/i,
-        /dependency\s+graph/i,
-        /code\s+map/i,
-        /explore\s+codebase/i,
-    ],
-    preload: [
-        /preload/i,
-        /cache\s+ahead/i,
-        /prefetch/i,
-        /warm\s+(up\s+)?cache/i,
-    ],
-    deepdive: [
-        /deep\s+dive/i,
-        /analyze\s+thoroughly/i,
-        /in-depth\s+analysis/i,
-        /comprehensive\s+review/i,
-        /detailed\s+examination/i,
-    ],
-    document: [
-        /document\s+(this|the)/i,
-        /generate\s+docs/i,
-        /add\s+documentation/i,
-        /write\s+readme/i,
-        /api\s+docs/i,
-        /jsdoc/i,
-    ],
-    refactor: [
-        /refactor/i,
-        /clean\s+up\s+code/i,
-        /improve\s+code\s+quality/i,
-        /restructure/i,
-        /simplify/i,
-        /make\s+more\s+readable/i,
-    ],
-    benchmark: [
-        /benchmark/i,
-        /performance\s+test/i,
-        /measure\s+speed/i,
-        /stress\s+test/i,
-        /load\s+test/i,
-    ],
-    testgaps: [
-        /test\s+coverage/i,
-        /missing\s+tests/i,
-        /untested\s+code/i,
-        /coverage\s+report/i,
-        /test\s+gaps/i,
-        /add\s+tests/i,
-    ],
-};
-/**
- * Worker configurations
- */
-const WORKER_CONFIGS = {
-    ultralearn: {
-        description: 'Deep knowledge acquisition and learning',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['research', 'analysis', 'synthesis'],
-    },
-    optimize: {
-        description: 'Performance optimization and tuning',
-        priority: 'high',
-        estimatedDuration: '30s',
-        capabilities: ['profiling', 'optimization', 'benchmarking'],
-    },
-    consolidate: {
-        description: 'Memory consolidation and cleanup',
-        priority: 'low',
-        estimatedDuration: '20s',
-        capabilities: ['memory-management', 'deduplication'],
-    },
-    predict: {
-        description: 'Predictive preloading and anticipation',
-        priority: 'normal',
-        estimatedDuration: '15s',
-        capabilities: ['prediction', 'caching', 'preloading'],
-    },
-    audit: {
-        description: 'Security analysis and vulnerability scanning',
-        priority: 'critical',
-        estimatedDuration: '45s',
-        capabilities: ['security', 'vulnerability-scanning', 'audit'],
-    },
-    map: {
-        description: 'Codebase mapping and architecture analysis',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['analysis', 'mapping', 'visualization'],
-    },
-    preload: {
-        description: 'Resource preloading and cache warming',
-        priority: 'low',
-        estimatedDuration: '10s',
-        capabilities: ['caching', 'preloading'],
-    },
-    deepdive: {
-        description: 'Deep code analysis and examination',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['analysis', 'review', 'understanding'],
-    },
-    document: {
-        description: 'Auto-documentation generation',
-        priority: 'normal',
-        estimatedDuration: '45s',
-        capabilities: ['documentation', 'writing', 'generation'],
-    },
-    refactor: {
-        description: 'Code refactoring suggestions',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['refactoring', 'code-quality', 'improvement'],
-    },
-    benchmark: {
-        description: 'Performance benchmarking',
-        priority: 'normal',
-        estimatedDuration: '60s',
-        capabilities: ['benchmarking', 'testing', 'measurement'],
-    },
-    testgaps: {
-        description: 'Test coverage analysis',
-        priority: 'normal',
-        estimatedDuration: '30s',
-        capabilities: ['testing', 'coverage', 'analysis'],
-    },
-};
-// In-memory worker tracking
-const activeWorkers = new Map();
-let workerIdCounter = 0;
-/**
- * Detect triggers from prompt text
- */
-function detectWorkerTriggers(text) {
-    const detectedTriggers = [];
-    let totalMatches = 0;
-    for (const [trigger, patterns] of Object.entries(WORKER_TRIGGER_PATTERNS)) {
-        for (const pattern of patterns) {
-            if (pattern.test(text)) {
-                if (!detectedTriggers.includes(trigger)) {
-                    detectedTriggers.push(trigger);
-                }
-                totalMatches++;
-            }
-        }
-    }
-    const confidence = detectedTriggers.length > 0
-        ? Math.min(1, totalMatches / (detectedTriggers.length * 2))
-        : 0;
-    return {
-        detected: detectedTriggers.length > 0,
-        triggers: detectedTriggers,
-        confidence,
-        context: text.slice(0, 100),
-    };
-}
-// Worker list tool
-export const hooksWorkerList = {
-    name: 'hooks/worker-list',
-    description: 'List all 12 background workers with status and capabilities',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            status: { type: 'string', description: 'Filter by status (all, running, completed, pending)' },
-            includeActive: { type: 'boolean', description: 'Include active worker instances' },
-        },
-    },
-    handler: async (params) => {
-        const statusFilter = params.status || 'all';
-        const includeActive = params.includeActive !== false;
-        const workers = Object.entries(WORKER_CONFIGS).map(([trigger, config]) => ({
-            trigger,
-            ...config,
-            patterns: WORKER_TRIGGER_PATTERNS[trigger].length,
-        }));
-        const activeList = includeActive
-            ? Array.from(activeWorkers.values()).filter(w => statusFilter === 'all' || w.status === statusFilter)
-            : [];
-        return {
-            workers,
-            total: 12,
-            active: {
-                instances: activeList,
-                count: activeList.length,
-                byStatus: {
-                    pending: activeList.filter(w => w.status === 'pending').length,
-                    running: activeList.filter(w => w.status === 'running').length,
-                    completed: activeList.filter(w => w.status === 'completed').length,
-                    failed: activeList.filter(w => w.status === 'failed').length,
-                },
-            },
-            performanceTargets: {
-                triggerDetection: '<5ms',
-                workerSpawn: '<50ms',
-                maxConcurrent: 10,
-            },
-        };
-    },
-};
-// Worker dispatch tool
-export const hooksWorkerDispatch = {
-    name: 'hooks/worker-dispatch',
-    description: 'Dispatch a background worker for analysis/optimization tasks',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trigger: {
-                type: 'string',
-                description: 'Worker trigger type',
-                enum: ['ultralearn', 'optimize', 'consolidate', 'predict', 'audit', 'map', 'preload', 'deepdive', 'document', 'refactor', 'benchmark', 'testgaps'],
-            },
-            context: { type: 'string', description: 'Context for the worker (file path, topic, etc.)' },
-            priority: { type: 'string', description: 'Priority (low, normal, high, critical)' },
-            background: { type: 'boolean', description: 'Run in background (non-blocking)' },
-        },
-        required: ['trigger'],
-    },
-    handler: async (params) => {
-        const trigger = params.trigger;
-        const context = params.context || 'default';
-        const priority = params.priority || WORKER_CONFIGS[trigger]?.priority || 'normal';
-        const background = params.background !== false;
-        if (!WORKER_CONFIGS[trigger]) {
-            return {
-                success: false,
-                error: `Unknown worker trigger: ${trigger}`,
-                availableTriggers: Object.keys(WORKER_CONFIGS),
-            };
-        }
-        const workerId = `worker_${trigger}_${++workerIdCounter}_${Date.now().toString(36)}`;
-        const config = WORKER_CONFIGS[trigger];
-        const worker = {
-            id: workerId,
-            trigger,
-            context,
-            status: 'running',
-            progress: 0,
-            phase: 'initializing',
-            startedAt: new Date(),
-        };
-        activeWorkers.set(workerId, worker);
-        // Update worker progress in background
-        if (background) {
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 50;
-                    w.phase = 'processing';
-                }
-            }, 500);
-            setTimeout(() => {
-                const w = activeWorkers.get(workerId);
-                if (w) {
-                    w.progress = 100;
-                    w.phase = 'completed';
-                    w.status = 'completed';
-                    w.completedAt = new Date();
-                }
-            }, 1500);
-        }
-        else {
-            worker.progress = 100;
-            worker.phase = 'completed';
-            worker.status = 'completed';
-            worker.completedAt = new Date();
-        }
-        return {
-            success: true,
-            workerId,
-            trigger,
-            context,
-            priority,
-            config: {
-                description: config.description,
-                estimatedDuration: config.estimatedDuration,
-                capabilities: config.capabilities,
-            },
-            status: background ? 'dispatched' : 'completed',
-            background,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Worker status tool
-export const hooksWorkerStatus = {
-    name: 'hooks/worker-status',
-    description: 'Get status of a specific worker or all active workers',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            workerId: { type: 'string', description: 'Specific worker ID to check' },
-            includeCompleted: { type: 'boolean', description: 'Include completed workers' },
-        },
-    },
-    handler: async (params) => {
-        const workerId = params.workerId;
-        const includeCompleted = params.includeCompleted !== false;
-        if (workerId) {
-            const worker = activeWorkers.get(workerId);
-            if (!worker) {
-                return {
-                    success: false,
-                    error: `Worker not found: ${workerId}`,
-                };
-            }
-            return {
-                success: true,
-                worker: {
-                    ...worker,
-                    duration: worker.completedAt
-                        ? worker.completedAt.getTime() - worker.startedAt.getTime()
-                        : Date.now() - worker.startedAt.getTime(),
-                },
-            };
-        }
-        const workers = Array.from(activeWorkers.values())
-            .filter(w => includeCompleted || w.status !== 'completed')
-            .map(w => ({
-            ...w,
-            duration: w.completedAt
-                ? w.completedAt.getTime() - w.startedAt.getTime()
-                : Date.now() - w.startedAt.getTime(),
-        }));
-        return {
-            success: true,
-            workers,
-            summary: {
-                total: workers.length,
-                running: workers.filter(w => w.status === 'running').length,
-                completed: workers.filter(w => w.status === 'completed').length,
-                failed: workers.filter(w => w.status === 'failed').length,
-            },
-        };
-    },
-};
-// Worker detect tool - detect triggers from prompt
-export const hooksWorkerDetect = {
-    name: 'hooks/worker-detect',
-    description: 'Detect worker triggers from user prompt (for UserPromptSubmit hook)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            prompt: { type: 'string', description: 'User prompt to analyze' },
-            autoDispatch: { type: 'boolean', description: 'Automatically dispatch detected workers' },
-            minConfidence: { type: 'number', description: 'Minimum confidence threshold (0-1)' },
-        },
-        required: ['prompt'],
-    },
-    handler: async (params) => {
-        const prompt = params.prompt;
-        const autoDispatch = params.autoDispatch;
-        const minConfidence = params.minConfidence || 0.5;
-        const detection = detectWorkerTriggers(prompt);
-        const result = {
-            prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
-            detection,
-            triggersFound: detection.triggers.length,
-        };
-        if (detection.detected && detection.confidence >= minConfidence) {
-            result.triggerDetails = detection.triggers.map(trigger => ({
-                trigger,
-                ...WORKER_CONFIGS[trigger],
-            }));
-            if (autoDispatch) {
-                const dispatched = [];
-                for (const trigger of detection.triggers) {
-                    const workerId = `worker_${trigger}_${++workerIdCounter}_${Date.now().toString(36)}`;
-                    activeWorkers.set(workerId, {
-                        id: workerId,
-                        trigger,
-                        context: prompt.slice(0, 100),
-                        status: 'running',
-                        progress: 0,
-                        phase: 'initializing',
-                        startedAt: new Date(),
-                    });
-                    dispatched.push(workerId);
-                    // Mark worker completion after processing
-                    setTimeout(() => {
-                        const w = activeWorkers.get(workerId);
-                        if (w) {
-                            w.progress = 100;
-                            w.phase = 'completed';
-                            w.status = 'completed';
-                            w.completedAt = new Date();
-                        }
-                    }, 1500);
-                }
-                result.autoDispatched = true;
-                result.workerIds = dispatched;
-            }
-        }
-        return result;
-    },
-};
-// Worker cancel tool
-export const hooksWorkerCancel = {
-    name: 'hooks/worker-cancel',
-    description: 'Cancel a running worker',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            workerId: { type: 'string', description: 'Worker ID to cancel' },
-        },
-        required: ['workerId'],
-    },
-    handler: async (params) => {
-        const workerId = params.workerId;
-        const worker = activeWorkers.get(workerId);
-        if (!worker) {
-            return {
-                success: false,
-                error: `Worker not found: ${workerId}`,
-            };
-        }
-        if (worker.status === 'completed' || worker.status === 'failed') {
-            return {
-                success: false,
-                error: `Worker already ${worker.status}`,
-            };
-        }
-        worker.status = 'failed';
-        worker.phase = 'cancelled';
-        worker.completedAt = new Date();
-        return {
-            success: true,
-            workerId,
-            cancelled: true,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Export all hooks tools
-export const hooksTools = [
-    hooksPreEdit,
-    hooksPostEdit,
-    hooksPreCommand,
-    hooksPostCommand,
-    hooksRoute,
-    hooksMetrics,
-    hooksList,
-    hooksPreTask,
-    hooksPostTask,
-    // New hooks
-    hooksExplain,
-    hooksPretrain,
-    hooksBuildAgents,
-    hooksTransfer,
-    hooksSessionStart,
-    hooksSessionEnd,
-    hooksSessionRestore,
-    hooksNotify,
-    hooksInit,
-    hooksIntelligence,
-    hooksIntelligenceReset,
-    hooksTrajectoryStart,
-    hooksTrajectoryStep,
-    hooksTrajectoryEnd,
-    hooksPatternStore,
-    hooksPatternSearch,
-    hooksIntelligenceStats,
-    hooksIntelligenceLearn,
-    hooksIntelligenceAttention,
-    // Worker tools
-    hooksWorkerList,
-    hooksWorkerDispatch,
-    hooksWorkerStatus,
-    hooksWorkerDetect,
-    hooksWorkerCancel,
-];
-export default hooksTools;
-//# sourceMappingURL=hooks-tools.js.map