monomind 2.7.12 → 2.7.14

package/packages/@monomind/cli/dist/src/mcp-tools/hooks-intelligence.js

@@ -1,888 +0,0 @@
-/**
- * Hooks Intelligence MCP Tools
- * MCP tool implementations for intelligence reset, trajectories, patterns,
- * intelligence stats/learn/attention, and model routing.
- * Extracted from hooks-tools.ts.
- * The simulated worker dispatch/status/detect/cancel tools were deleted with
- * the worker daemon -- real workers live in @monoes/hooks (`hooks worker run`).
- */
-import { existsSync, readdirSync, unlinkSync } from 'fs';
-import { join } from 'path';
-import { getProjectCwd } from './types.js';
-import { activeTrajectories, getRealSearchFunction, getRealStoreFunction, getSONAOptimizer, getEWCConsolidator, getIntelligenceStatsFromMemory, } from './hooks-embedding.js';
-// Intelligence reset hook
-export const hooksIntelligenceReset = {
-    name: 'hooks_intelligence-reset',
-    description: 'Reset intelligence learning state',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    handler: async () => {
-        const cwd = getProjectCwd();
-        const cleared = {
-            trajectories: 0,
-            patterns: 0,
-            dataFiles: 0,
-            neuralFiles: 0,
-        };
-        const deletedFiles = [];
-        // Clear intelligence data files if they exist
-        const dataFiles = [
-            join(cwd, '.monomind', 'data', 'auto-memory-store.json'),
-            join(cwd, '.monomind', 'data', 'graph-state.json'),
-            join(cwd, '.monomind', 'data', 'ranked-context.json'),
-        ];
-        for (const filePath of dataFiles) {
-            if (existsSync(filePath)) {
-                try {
-                    unlinkSync(filePath);
-                    cleared.dataFiles++;
-                    deletedFiles.push(filePath);
-                }
-                catch {
-                    // Skip files that cannot be deleted
-                }
-            }
-        }
-        // Clear neural directory if it exists
-        const neuralDir = join(cwd, '.monomind', 'neural');
-        if (existsSync(neuralDir)) {
-            try {
-                const files = readdirSync(neuralDir);
-                for (const file of files) {
-                    try {
-                        const filePath = join(neuralDir, file);
-                        unlinkSync(filePath);
-                        cleared.neuralFiles++;
-                        deletedFiles.push(filePath);
-                    }
-                    catch {
-                        // Skip files that cannot be deleted
-                    }
-                }
-            }
-            catch {
-                // Directory read failed
-            }
-        }
-        // Clear in-memory trajectories
-        cleared.trajectories = activeTrajectories.size;
-        activeTrajectories.clear();
-        return {
-            reset: true,
-            cleared,
-            deletedFiles,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Intelligence trajectory hooks - REAL implementation using activeTrajectories
-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) => {
-        // Cap task and agent lengths to prevent the trajectory map from accumulating
-        // large strings (up to MAX_TRAJECTORIES × uncapped length = potential GB of RAM).
-        const MAX_TASK_LEN = 4 * 1024; // 4 KB — same cap as trajectory-step fields
-        const MAX_AGENT_LEN = 256;
-        const rawTask = params.task;
-        const task = typeof rawTask === 'string' && rawTask.length > MAX_TASK_LEN
-            ? rawTask.slice(0, MAX_TASK_LEN)
-            : rawTask;
-        const rawAgent = params.agent || 'coder';
-        const agent = typeof rawAgent === 'string' && rawAgent.length > MAX_AGENT_LEN
-            ? rawAgent.slice(0, MAX_AGENT_LEN)
-            : rawAgent;
-        const trajectoryId = `traj-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-        const startedAt = new Date().toISOString();
-        // Create real trajectory entry in memory
-        const trajectory = {
-            id: trajectoryId,
-            task,
-            agent,
-            steps: [],
-            startedAt,
-        };
-        const MAX_TRAJECTORIES = 10000;
-        if (activeTrajectories.size >= MAX_TRAJECTORIES) {
-            // Evict the oldest trajectory
-            const oldest = activeTrajectories.keys().next().value;
-            if (oldest)
-                activeTrajectories.delete(oldest);
-        }
-        activeTrajectories.set(trajectoryId, trajectory);
-        return {
-            trajectoryId,
-            task,
-            agent,
-            started: startedAt,
-            status: 'recording',
-            implementation: 'real-trajectory-tracking',
-            activeCount: activeTrajectories.size,
-        };
-    },
-};
-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;
-        // Cap action and result strings to prevent unbounded in-memory growth when
-        // trajectory-step is called many times with large payloads.
-        const MAX_STEP_STRING_LEN = 4 * 1024; // 4 KB per field
-        const MAX_STEPS_PER_TRAJECTORY = 1000;
-        const rawAction = params.action;
-        const rawResult = params.result || 'success';
-        const action = typeof rawAction === 'string' && rawAction.length > MAX_STEP_STRING_LEN
-            ? rawAction.slice(0, MAX_STEP_STRING_LEN)
-            : rawAction;
-        const result = typeof rawResult === 'string' && rawResult.length > MAX_STEP_STRING_LEN
-            ? rawResult.slice(0, MAX_STEP_STRING_LEN)
-            : rawResult;
-        const quality = params.quality || 0.85;
-        const timestamp = new Date().toISOString();
-        const stepId = `step-${Date.now()}`;
-        // Add step to real trajectory if it exists
-        const trajectory = activeTrajectories.get(trajectoryId);
-        if (trajectory) {
-            if (trajectory.steps.length >= MAX_STEPS_PER_TRAJECTORY) {
-                // Drop the oldest step to keep the array bounded
-                trajectory.steps.shift();
-            }
-            trajectory.steps.push({
-                action,
-                result,
-                quality,
-                timestamp,
-            });
-        }
-        return {
-            trajectoryId,
-            stepId,
-            action,
-            result,
-            quality,
-            recorded: !!trajectory,
-            timestamp,
-            totalSteps: trajectory?.steps.length || 0,
-            implementation: trajectory ? 'real-step-recording' : 'trajectory-not-found',
-        };
-    },
-};
-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;
-        const feedback = params.feedback;
-        const endedAt = new Date().toISOString();
-        const startTime = Date.now();
-        // Get and finalize real trajectory
-        const trajectory = activeTrajectories.get(trajectoryId);
-        let persistResult = { success: false };
-        if (trajectory) {
-            trajectory.success = success;
-            trajectory.endedAt = endedAt;
-            // Persist trajectory to database using real store
-            const storeFn = await getRealStoreFunction();
-            if (storeFn) {
-                try {
-                    // Create trajectory summary for embedding
-                    const summary = `Task: ${trajectory.task} | Agent: ${trajectory.agent} | Steps: ${trajectory.steps.length} | Success: ${success}${feedback ? ` | Feedback: ${feedback}` : ''}`;
-                    persistResult = await storeFn({
-                        key: `trajectory-${trajectoryId}`,
-                        value: JSON.stringify({
-                            ...trajectory,
-                            feedback,
-                        }),
-                        namespace: 'trajectories',
-                        generateEmbeddingFlag: true, // Generate embedding for semantic search
-                        tags: [trajectory.agent, success ? 'success' : 'failure', 'sona-trajectory'],
-                    });
-                }
-                catch (error) {
-                    persistResult = { success: false, error: error instanceof Error ? error.message : String(error) };
-                }
-            }
-            // Remove from active trajectories
-            activeTrajectories.delete(trajectoryId);
-            // Bridge to the local intelligence ReasoningBank/SONA confidence-learning
-            // loop (src/memory/intelligence.ts). Previously this handler only wrote
-            // to the legacy JSON memory store (namespace 'trajectories') and the
-            // SONA routing optimizer's .swarm/sona-patterns.json — neither of which
-            // the ReasoningBank read from live, so trajectories recorded through
-            // this MCP tool (the path Claude Code actually calls) never fed the
-            // pattern store that `findSimilarPatterns`/`suggestAgentsFromIntelligence`
-            // read from. Recording a summary 'result' step here generates an
-            // embedding, stores a searchable pattern, and — because type 'result'
-            // triggers intelligence.ts's endTrajectory+distillLearning — applies
-            // the success/failure verdict to any semantically similar patterns.
-            try {
-                const intel = await import('../memory/intelligence.js');
-                await intel.initializeIntelligence();
-                const summary = `Task: ${trajectory.task} | Agent: ${trajectory.agent} | Steps: ${trajectory.steps.length} | Success: ${success}${feedback ? ` | Feedback: ${feedback}` : ''}`;
-                await intel.recordStep({
-                    type: 'result',
-                    content: summary,
-                    metadata: {
-                        verdict: success ? 'success' : 'failure',
-                        trajectoryId,
-                        agent: trajectory.agent,
-                    },
-                });
-            }
-            catch (e) {
-                // Non-fatal: intelligence bridge unavailable, trajectory is still
-                // persisted via the legacy store above.
-                if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                    console.error('[hooks-intelligence] intelligence bridge recordStep failed:', e);
-            }
-        }
-        // SONA Learning - process trajectory outcome for routing optimization
-        let sonaResult = {
-            learned: false, patternKey: '', confidence: 0
-        };
-        let ewcResult = {
-            consolidated: false, penalty: 0
-        };
-        if (trajectory && persistResult.success) {
-            // Try SONA learning
-            const sona = await getSONAOptimizer();
-            if (sona) {
-                try {
-                    const outcome = {
-                        trajectoryId,
-                        task: trajectory.task,
-                        agent: trajectory.agent,
-                        success,
-                        steps: trajectory.steps,
-                        feedback,
-                        duration: trajectory.startedAt
-                            ? new Date(endedAt).getTime() - new Date(trajectory.startedAt).getTime()
-                            : 0,
-                    };
-                    const result = sona.processTrajectoryOutcome(outcome);
-                    sonaResult = {
-                        learned: result.learned,
-                        patternKey: result.patternKey,
-                        confidence: result.confidence,
-                    };
-                }
-                catch (e) {
-                    // SONA learning failed, continue without it
-                    if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                        console.error('[hooks-intelligence] SONA processTrajectoryOutcome failed:', e);
-                }
-            }
-            // Try EWC++ consolidation on successful trajectories
-            if (success) {
-                const ewc = await getEWCConsolidator();
-                if (ewc) {
-                    try {
-                        // Record gradient sample for Fisher matrix update
-                        // Create a simple gradient from trajectory steps
-                        const gradients = new Array(384).fill(0).map((_, i) => Math.sin(i * 0.01) * (trajectory.steps.length / 10));
-                        ewc.recordGradient(`trajectory-${trajectoryId}`, gradients, success);
-                        const stats = ewc.getConsolidationStats();
-                        ewcResult = {
-                            consolidated: true,
-                            penalty: stats.avgPenalty,
-                        };
-                    }
-                    catch (e) {
-                        // EWC consolidation failed, continue without it
-                        if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                            console.error('[hooks-intelligence] EWC consolidation failed:', e);
-                    }
-                }
-            }
-        }
-        const learningTimeMs = Date.now() - startTime;
-        return {
-            trajectoryId,
-            success,
-            ended: endedAt,
-            persisted: persistResult.success,
-            persistedId: persistResult.id,
-            learning: {
-                sonaUpdate: sonaResult.learned,
-                sonaPatternKey: sonaResult.patternKey || undefined,
-                sonaConfidence: sonaResult.confidence || undefined,
-                ewcConsolidation: ewcResult.consolidated,
-                ewcPenalty: ewcResult.penalty || undefined,
-                patternsExtracted: trajectory?.steps.length || 0,
-                learningTimeMs,
-            },
-            trajectory: trajectory ? {
-                task: trajectory.task,
-                agent: trajectory.agent,
-                totalSteps: trajectory.steps.length,
-                duration: trajectory.startedAt ? new Date(endedAt).getTime() - new Date(trajectory.startedAt).getTime() : 0,
-            } : null,
-            implementation: sonaResult.learned ? 'real-sona-learning' : (persistResult.success ? 'real-persistence' : 'memory-only'),
-            note: sonaResult.learned
-                ? `SONA learned pattern "${sonaResult.patternKey}" with ${(sonaResult.confidence * 100).toFixed(1)}% confidence`
-                : (persistResult.success ? 'Trajectory persisted for future learning' : (persistResult.error || 'Trajectory not found')),
-        };
-    },
-};
-// Pattern store/search hooks - REAL implementation using storeEntry
-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) => {
-        // Cap pattern and type lengths to prevent DoS via large embedding generation
-        // and unbounded database writes.  16 KB matches the cap in neural_patterns store.
-        const MAX_PATTERN_LEN = 16 * 1024; // 16 KB
-        const MAX_TYPE_LEN = 256;
-        const rawPattern = params.pattern;
-        const pattern = typeof rawPattern === 'string' && rawPattern.length > MAX_PATTERN_LEN
-            ? rawPattern.slice(0, MAX_PATTERN_LEN)
-            : rawPattern;
-        const rawType = params.type || 'general';
-        const type = typeof rawType === 'string' && rawType.length > MAX_TYPE_LEN
-            ? rawType.slice(0, MAX_TYPE_LEN)
-            : rawType;
-        const confidence = params.confidence || 0.8;
-        const metadata = params.metadata;
-        const timestamp = new Date().toISOString();
-        const patternId = `pattern-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-        // Phase 3: Try ReasoningBank via bridge first
-        let reasoningResult = null;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            reasoningResult = await bridge.bridgeStorePattern({ pattern, taskType: type, confidence });
-        }
-        catch {
-            // Bridge not available
-        }
-        // Fallback: persist using memory-initializer store
-        let storeResult = { success: false };
-        if (!reasoningResult) {
-            const storeFn = await getRealStoreFunction();
-            if (storeFn) {
-                try {
-                    storeResult = await storeFn({
-                        key: patternId,
-                        value: JSON.stringify({ pattern, type, confidence, metadata, timestamp }),
-                        namespace: 'pattern',
-                        generateEmbeddingFlag: true,
-                        tags: [type, `confidence-${Math.round(confidence * 100)}`, 'reasoning-pattern'],
-                    });
-                }
-                catch (error) {
-                    storeResult = { success: false, error: error instanceof Error ? error.message : String(error) };
-                }
-            }
-        }
-        const success = reasoningResult?.success || storeResult.success;
-        const controller = reasoningResult?.success ? 'lancedb' : (storeResult.success ? 'bridge-store' : 'none');
-        return {
-            patternId: reasoningResult?.id || storeResult.id || patternId,
-            pattern,
-            type,
-            confidence,
-            indexed: success,
-            hnswIndexed: success && (!!storeResult.embedding || controller === 'lancedb'),
-            embedding: storeResult.embedding,
-            timestamp,
-            controller,
-            implementation: controller === 'lancedb' ? 'lancedb-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
-            note: controller === 'lancedb'
-                ? 'Pattern stored via SQLite-backed memory bridge with HNSW indexing'
-                : (storeResult.success ? 'Pattern stored with vector embedding for semantic search' : (storeResult.error || 'Store function unavailable')),
-        };
-    },
-};
-export const hooksPatternSearch = {
-    name: 'hooks_intelligence_pattern-search',
-    description: 'Search patterns using REAL vector search (HNSW when available, brute-force fallback)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            query: { type: 'string', description: 'Search query' },
-            topK: { type: 'number', description: 'Number of results' },
-            minConfidence: { type: 'number', description: 'Minimum similarity threshold (0-1)' },
-            namespace: { type: 'string', description: 'Namespace to search (default: pattern)' },
-        },
-        required: ['query'],
-    },
-    handler: async (params) => {
-        // Cap query length to prevent DoS via large embedding generation (same
-        // class of bug fixed in neural_patterns search and hooksPatternStore).
-        const MAX_SEARCH_QUERY_LEN = 16 * 1024; // 16 KB — matches neural_patterns cap
-        const MAX_TOP_K = 100;
-        const rawQuery = params.query;
-        const query = typeof rawQuery === 'string' && rawQuery.length > MAX_SEARCH_QUERY_LEN
-            ? rawQuery.slice(0, MAX_SEARCH_QUERY_LEN)
-            : rawQuery;
-        const rawTopK = params.topK;
-        const topK = Number.isFinite(rawTopK) && rawTopK > 0
-            ? Math.min(Math.floor(rawTopK), MAX_TOP_K)
-            : 5;
-        const minConfidence = params.minConfidence || 0.3;
-        const namespace = params.namespace || 'pattern';
-        // Phase 3: Try ReasoningBank search via bridge first
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            const rbResult = await bridge.bridgeSearchPatterns({ query, limit: topK });
-            if (rbResult && rbResult.patterns.length > 0) {
-                return {
-                    query,
-                    results: rbResult.patterns
-                        .filter((r) => r.score >= minConfidence)
-                        .map((r) => ({
-                        patternId: r.id,
-                        pattern: r.pattern,
-                        similarity: r.score,
-                        confidence: r.score,
-                        namespace,
-                    })),
-                    searchTimeMs: 0,
-                    backend: 'lancedb',
-                    note: 'Results from SQLite-backed memory bridge',
-                };
-            }
-        }
-        catch {
-            // Bridge not available — fall through
-        }
-        // Fallback: Try real vector search via memory-initializer
-        const searchFn = await getRealSearchFunction();
-        if (searchFn) {
-            try {
-                const searchResult = await searchFn({
-                    query,
-                    namespace,
-                    limit: topK,
-                    threshold: minConfidence,
-                });
-                if (searchResult.success && searchResult.results.length > 0) {
-                    return {
-                        query,
-                        results: searchResult.results.map(r => ({
-                            patternId: r.id,
-                            pattern: r.content,
-                            similarity: r.score,
-                            confidence: r.score,
-                            namespace: r.namespace,
-                            key: r.key,
-                        })),
-                        searchTimeMs: searchResult.searchTime,
-                        backend: 'real-vector-search',
-                        note: 'Results from HNSW/SQLite vector search (BM25 hybrid)',
-                    };
-                }
-                // No results found
-                return {
-                    query,
-                    results: [],
-                    searchTimeMs: searchResult.searchTime,
-                    backend: 'real-vector-search',
-                    note: searchResult.error || 'No matching patterns found. Store patterns first using memory/store with namespace "pattern".',
-                };
-            }
-            catch (error) {
-                // Fall through to empty response with error
-                return {
-                    query,
-                    results: [],
-                    searchTimeMs: 0,
-                    backend: 'error',
-                    error: String(error),
-                    note: 'Vector search failed. Ensure memory database is initialized.',
-                };
-            }
-        }
-        // No search function available
-        return {
-            query,
-            results: [],
-            searchTimeMs: 0,
-            backend: 'unavailable',
-            note: 'Real vector search not available. Initialize memory database with: monomind memory init',
-        };
-    },
-};
-// Intelligence stats hook
-export const hooksIntelligenceStats = {
-    name: 'hooks_intelligence_stats',
-    description: 'Get intelligence-layer statistics (pattern/trajectory logging)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            detailed: { type: 'boolean', description: 'Include detailed stats' },
-        },
-    },
-    handler: async (params) => {
-        const detailed = params.detailed;
-        // Get REAL statistics from actual implementations
-        const sona = await getSONAOptimizer();
-        const ewc = await getEWCConsolidator();
-        // Fallback to memory store for legacy data
-        const memoryStats = getIntelligenceStatsFromMemory();
-        // SONA stats from real implementation
-        let sonaStats = {
-            trajectoriesTotal: memoryStats.trajectories.total,
-            trajectoriesSuccessful: memoryStats.trajectories.successful,
-            avgLearningTimeMs: 0,
-            patternsLearned: memoryStats.patterns.learned,
-            patternCategories: memoryStats.patterns.categories,
-            successRate: 0,
-            implementation: 'memory-fallback',
-        };
-        if (sona) {
-            const realSona = sona.getStats();
-            const totalRoutes = realSona.successfulRoutings + realSona.failedRoutings;
-            sonaStats = {
-                trajectoriesTotal: realSona.trajectoriesProcessed,
-                trajectoriesSuccessful: realSona.successfulRoutings,
-                avgLearningTimeMs: realSona.lastUpdate ? 0.042 : 0, // Theoretical when active
-                patternsLearned: realSona.totalPatterns,
-                patternCategories: { learned: realSona.totalPatterns }, // Simplified
-                successRate: totalRoutes > 0
-                    ? Math.round((realSona.successfulRoutings / totalRoutes) * 100) / 100
-                    : 0,
-                implementation: 'real-sona',
-            };
-        }
-        // EWC++ stats from real implementation
-        let ewcStats = {
-            consolidations: 0,
-            catastrophicForgettingPrevented: 0,
-            fisherUpdates: 0,
-            avgPenalty: 0,
-            totalPatterns: 0,
-            implementation: 'not-loaded',
-        };
-        if (ewc) {
-            const realEwc = ewc.getConsolidationStats();
-            ewcStats = {
-                consolidations: realEwc.consolidationCount,
-                catastrophicForgettingPrevented: realEwc.highImportancePatterns,
-                fisherUpdates: realEwc.consolidationCount,
-                avgPenalty: Math.round(realEwc.avgPenalty * 1000) / 1000,
-                totalPatterns: realEwc.totalPatterns,
-                implementation: 'real-ewc++',
-            };
-        }
-        // MoE stats from real implementation
-        let moeStats = {
-            expertsTotal: 8,
-            expertsActive: 0,
-            routingDecisions: memoryStats.routing.decisions,
-            avgRoutingTimeMs: 0,
-            avgConfidence: memoryStats.routing.avgConfidence,
-            loadBalance: null,
-            implementation: 'not-loaded',
-        };
-        // Flash Attention stats (native MoE/Flash removed in lean build — defaults only)
-        const flashStats = {
-            speedup: 1.0,
-            avgComputeTimeMs: 0,
-            blockSize: 64,
-            implementation: 'not-loaded',
-        };
-        // LoRA Adapter removed — superseded by SONA instant adaptation
-        const loraStats = {
-            rank: 8,
-            alpha: 16,
-            adaptations: 0,
-            avgLoss: 0,
-            implementation: 'not-loaded',
-        };
-        const stats = {
-            sona: sonaStats,
-            moe: moeStats,
-            ewc: ewcStats,
-            flash: flashStats,
-            lora: loraStats,
-            hnsw: {
-                indexSize: memoryStats.memory.indexSize,
-                avgSearchTimeMs: 0.12,
-                cacheHitRate: memoryStats.memory.totalAccessCount > 0
-                    ? Math.min(0.95, 0.5 + (memoryStats.memory.totalAccessCount / 1000))
-                    : 0.78,
-                memoryUsageMb: Math.round(memoryStats.memory.memorySizeBytes / 1024 / 1024 * 100) / 100,
-            },
-            dataSource: sona ? 'real-implementations' : 'memory-fallback',
-            lastUpdated: new Date().toISOString(),
-        };
-        if (detailed) {
-            return {
-                ...stats,
-                implementationStatus: {
-                    sona: sona ? 'loaded' : 'not-loaded',
-                    ewc: ewc ? 'loaded' : 'not-loaded',
-                    moe: 'not-loaded',
-                    flash: 'not-loaded',
-                    lora: 'not-loaded',
-                },
-                performance: {
-                    sonaLearningMs: sonaStats.avgLearningTimeMs,
-                    moeRoutingMs: moeStats.avgRoutingTimeMs,
-                    flashSpeedup: flashStats.speedup,
-                    ewcPenalty: ewcStats.avgPenalty,
-                },
-            };
-        }
-        return stats;
-    },
-};
-// Intelligence learn hook
-export const hooksIntelligenceLearn = {
-    name: 'hooks_intelligence_learn',
-    description: 'Run a consolidation pass over the local keyword-pattern store: time-decay confidence weighting, pruning, and an EWC++-style quadratic penalty derived from squared embedding magnitudes. There are no gradients and no model — no ML training occurs.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            trajectoryIds: { type: 'array', items: { type: 'string' }, 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();
-        // Get SONA statistics
-        let sonaStats = {
-            totalPatterns: 0,
-            successfulRoutings: 0,
-            failedRoutings: 0,
-            trajectoriesProcessed: 0,
-            avgConfidence: 0,
-        };
-        const sona = await getSONAOptimizer();
-        if (sona) {
-            const stats = sona.getStats();
-            sonaStats = {
-                totalPatterns: stats.totalPatterns,
-                successfulRoutings: stats.successfulRoutings,
-                failedRoutings: stats.failedRoutings,
-                trajectoriesProcessed: stats.trajectoriesProcessed,
-                avgConfidence: stats.avgConfidence,
-            };
-        }
-        // Get EWC++ statistics and optionally trigger consolidation
-        let ewcStats = {
-            consolidation: false,
-            fisherUpdated: false,
-            forgettingPrevented: 0,
-            avgPenalty: 0,
-        };
-        if (consolidate) {
-            const ewc = await getEWCConsolidator();
-            if (ewc) {
-                const stats = ewc.getConsolidationStats();
-                ewcStats = {
-                    consolidation: true,
-                    fisherUpdated: stats.consolidationCount > 0,
-                    forgettingPrevented: stats.highImportancePatterns,
-                    avgPenalty: stats.avgPenalty,
-                };
-            }
-        }
-        return {
-            learned: sonaStats.totalPatterns > 0,
-            duration: Date.now() - startTime,
-            updates: {
-                trajectoriesProcessed: sonaStats.trajectoriesProcessed,
-                patternsLearned: sonaStats.totalPatterns,
-                successRate: sonaStats.trajectoriesProcessed > 0
-                    ? (sonaStats.successfulRoutings / (sonaStats.successfulRoutings + sonaStats.failedRoutings) * 100).toFixed(1) + '%'
-                    : '0%',
-            },
-            ewc: consolidate ? ewcStats : null,
-            confidence: {
-                average: sonaStats.avgConfidence,
-                implementation: sona ? 'real-sona' : 'not-available',
-            },
-            implementation: sona ? 'real-sona-learning' : 'placeholder',
-        };
-    },
-};
-// Intelligence attention hook
-export const hooksIntelligenceAttention = {
-    name: 'hooks_intelligence_attention',
-    description: 'Compute attention-weighted similarity (pure-JS cosine/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 startTime = performance.now();
-        let implementation = 'placeholder';
-        const results = [];
-        // Native MoE-router / Flash-attention backends were removed in the lean build.
-        // Both modes degrade to the honest empty result handled below.
-        void mode;
-        // If no real implementation worked, return empty with honest marker
-        if (results.length === 0) {
-            implementation = 'none';
-        }
-        const computeTimeMs = performance.now() - startTime;
-        return {
-            query,
-            mode,
-            results,
-            stats: {
-                computeTimeMs,
-                speedup: implementation.startsWith('real-') ? computeTimeMs : null,
-                _stub: implementation === 'none',
-                _note: implementation === 'none' ? 'Pure-JS similarity only; native attention backends are not part of the lean build.' : undefined,
-            },
-            implementation,
-        };
-    },
-};
-// Model route tool - intelligent model selection
-export const hooksModelRoute = {
-    name: 'hooks_model-route',
-    description: 'Route task to optimal Claude model (haiku/sonnet/opus) based on complexity',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task description to analyze' },
-            preferSpeed: { type: 'boolean', description: 'Prefer faster models when possible' },
-            preferCost: { type: 'boolean', description: 'Prefer cheaper models when possible' },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        // Cap task: analyzeComplexityFallback calls .toLowerCase() and O(n) .includes()
-        // for each keyword; an unbounded task string causes event-loop DoS.
-        const MAX_MODEL_ROUTE_TASK_LEN = 16 * 1024;
-        const rawTask = params.task;
-        const task = typeof rawTask === 'string' && rawTask.length > MAX_MODEL_ROUTE_TASK_LEN
-            ? rawTask.slice(0, MAX_MODEL_ROUTE_TASK_LEN)
-            : rawTask;
-        // Native neural model-router removed in the lean build — keyword complexity heuristic.
-        const complexity = analyzeComplexityFallback(task);
-        return {
-            model: complexity > 0.7 ? 'opus' : complexity > 0.4 ? 'sonnet' : 'haiku',
-            confidence: 0.7,
-            complexity,
-            reasoning: 'Keyword complexity heuristic',
-            implementation: 'heuristic',
-        };
-    },
-};
-// Model route outcome - record outcome for learning
-export const hooksModelOutcome = {
-    name: 'hooks_model-outcome',
-    description: 'Record model routing outcome for learning',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Original task' },
-            model: { type: 'string', enum: ['haiku', 'sonnet', 'opus'], description: 'Model used' },
-            outcome: { type: 'string', enum: ['success', 'failure', 'escalated'], description: 'Task outcome' },
-            verifier_type: { type: 'string', enum: ['tsc', 'vitest', 'eslint', 'llm_judge'], description: 'RLVR verifier type for grounded reward signal' },
-            exit_code: { type: 'number', description: 'Verifier exit code (0 = pass); overrides outcome when verifier_type is set' },
-        },
-        required: ['task', 'model', 'outcome'],
-    },
-    handler: async (params) => {
-        // Cap task: even though the response only reflects task.slice(0, 50), an
-        // unbounded task string causes unnecessary memory allocation before the slice.
-        const MAX_MODEL_OUTCOME_TASK_LEN = 16 * 1024;
-        const rawOutcomeTask = params.task;
-        const task = typeof rawOutcomeTask === 'string' && rawOutcomeTask.length > MAX_MODEL_OUTCOME_TASK_LEN
-            ? rawOutcomeTask.slice(0, MAX_MODEL_OUTCOME_TASK_LEN)
-            : rawOutcomeTask;
-        const model = params.model;
-        // RLVR: derive effective outcome from verifier exit_code when provided
-        // Source: https://github.com/opendilab/awesome-RLVR
-        const verifierType = params.verifier_type;
-        const exitCode = params.exit_code;
-        const effectiveOutcome = verifierType !== undefined && exitCode !== undefined
-            ? (exitCode === 0 ? 'success' : 'failure')
-            : params.outcome;
-        const outcome = effectiveOutcome;
-        // Native model-router removed in the lean build — outcome is acknowledged but not
-        // fed to a neural learner (keyword routing has no online-learning store).
-        return {
-            recorded: true,
-            task: task.slice(0, 50),
-            model,
-            outcome,
-            timestamp: new Date().toISOString(),
-        };
-    },
-};
-// Model router stats
-export const hooksModelStats = {
-    name: 'hooks_model-stats',
-    description: 'Get model routing statistics',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    handler: async () => {
-        // Native model-router removed in the lean build — no neural routing stats to report.
-        return {
-            available: false,
-            message: 'Model router not available in the lean build (keyword routing has no stats)',
-        };
-    },
-};
-// Simple fallback complexity analyzer
-function analyzeComplexityFallback(task) {
-    const taskLower = task.toLowerCase();
-    // High complexity indicators
-    const highIndicators = ['architect', 'design', 'refactor', 'security', 'audit', 'complex', 'analyze'];
-    const highCount = highIndicators.filter(ind => taskLower.includes(ind)).length;
-    // Low complexity indicators
-    const lowIndicators = ['simple', 'typo', 'format', 'rename', 'comment'];
-    const lowCount = lowIndicators.filter(ind => taskLower.includes(ind)).length;
-    // Base on length
-    const lengthScore = Math.min(1, task.length / 200);
-    return Math.min(1, Math.max(0, 0.3 + highCount * 0.2 - lowCount * 0.15 + lengthScore * 0.2));
-}
-//# sourceMappingURL=hooks-intelligence.js.map