@monoes/monomindcli 1.14.6 → 1.15.0

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

@@ -1,3398 +1,10 @@
 /**
- * Hooks MCP Tools
- * Provides intelligent hooks functionality via MCP protocol
+ * Hooks MCP Tools — Registration Layer
+ * Thin registration module that aggregates all hooks MCP tools into a single array.
+ * Business logic lives in hooks-embedding.ts, hooks-routing.ts, and hooks-intelligence.ts.
  */
-import { mkdirSync, writeFileSync, renameSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
-import { dirname, join, resolve, sep } from 'path';
-import { getProjectCwd } from './types.js';
-import { randomUUID } from 'node:crypto';
-import { recordRoute, joinOutcome, joinLatestUnresolved } from '../monovector/route-outcomes.js';
-import { recordCommand, deriveRecentSuccess } from '../monovector/command-outcomes.js';
-// Base dir for per-route outcome records — sits alongside routing-outcomes.json
-function getRouteOutcomesBaseDir() {
-    return join(getProjectCwd(), '.monomind');
-}
-// Real vector search functions - lazy loaded to avoid circular imports
-let searchEntriesFn = null;
-async function getRealSearchFunction() {
-    if (!searchEntriesFn) {
-        try {
-            const { searchEntries } = await import('../memory/memory-initializer.js');
-            searchEntriesFn = searchEntries;
-        }
-        catch {
-            searchEntriesFn = null;
-        }
-    }
-    return searchEntriesFn;
-}
-// Real store function - lazy loaded
-let storeEntryFn = null;
-async function getRealStoreFunction() {
-    if (!storeEntryFn) {
-        try {
-            const { storeEntry } = await import('../memory/memory-initializer.js');
-            storeEntryFn = storeEntry;
-        }
-        catch {
-            storeEntryFn = null;
-        }
-    }
-    return storeEntryFn;
-}
-// =============================================================================
-// Neural Module Lazy Loaders (SONA, EWC++, MoE, LoRA, Flash Attention)
-// =============================================================================
-// SONA Optimizer - lazy loaded
-let sonaOptimizer = null;
-async function getSONAOptimizer() {
-    if (!sonaOptimizer) {
-        try {
-            const { getSONAOptimizer: getSona } = await import('../memory/sona-optimizer.js');
-            sonaOptimizer = await getSona();
-        }
-        catch {
-            sonaOptimizer = null;
-        }
-    }
-    return sonaOptimizer;
-}
-// EWC++ Consolidator - lazy loaded
-let ewcConsolidator = null;
-async function getEWCConsolidator() {
-    if (!ewcConsolidator) {
-        try {
-            const { getEWCConsolidator: getEWC } = await import('../memory/ewc-consolidation.js');
-            ewcConsolidator = await getEWC();
-        }
-        catch {
-            ewcConsolidator = null;
-        }
-    }
-    return ewcConsolidator;
-}
-function generateSimpleEmbedding(text, dimension = 384) {
-    // Simple deterministic embedding based on character codes
-    // This is for routing purposes where we need consistent, fast embeddings
-    const embedding = new Float32Array(dimension);
-    const normalized = text.toLowerCase().replace(/[^a-z0-9\s]/g, '');
-    const words = normalized.split(/\s+/).filter(w => w.length > 0);
-    // Combine word-level and character-level features
-    for (let i = 0; i < dimension; i++) {
-        let value = 0;
-        // Word-level features
-        for (let w = 0; w < words.length; w++) {
-            const word = words[w];
-            for (let c = 0; c < word.length; c++) {
-                const charCode = word.charCodeAt(c);
-                value += Math.sin((charCode * (i + 1) + w * 17 + c * 23) * 0.0137);
-            }
-        }
-        // Character-level features
-        for (let c = 0; c < text.length; c++) {
-            value += Math.cos((text.charCodeAt(c) * (i + 1) + c * 7) * 0.0073);
-        }
-        embedding[i] = value / Math.max(1, text.length);
-    }
-    // Normalize
-    let norm = 0;
-    for (let i = 0; i < dimension; i++) {
-        norm += embedding[i] * embedding[i];
-    }
-    norm = Math.sqrt(norm);
-    if (norm > 0) {
-        for (let i = 0; i < dimension; i++) {
-            embedding[i] /= norm;
-        }
-    }
-    return embedding;
-}
-// ── Runtime routing outcome persistence ──────────────────────────────
-// Closes the learning loop: post-task records outcomes → route loads them.
-// Evaluated lazily via getter so it uses runtime CWD, not import-time CWD
-function getRoutingOutcomesPath() {
-    return join(getProjectCwd(), '.monomind', 'routing-outcomes.json');
-}
-const ROUTING_STOPWORDS = new Set([
-    'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being', 'have', 'has', 'had',
-    'do', 'does', 'did', 'will', 'would', 'could', 'should', 'may', 'might', 'shall', 'can',
-    'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as', 'into', 'through', 'during',
-    'before', 'after', 'above', 'below', 'between', 'under', 'again', 'further', 'then', 'once',
-    'it', 'its', 'this', 'that', 'these', 'those', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
-    'he', 'she', 'they', 'them', 'and', 'but', 'or', 'nor', 'not', 'no', 'so', 'if', 'when', 'than',
-    'very', 'just', 'also', 'only', 'both', 'each', 'all', 'any', 'few', 'more', 'most', 'other',
-    'some', 'such', 'same', 'new', 'now', 'here', 'there', 'where', 'how', 'what', 'which', 'who',
-]);
-function extractKeywords(text) {
-    if (!text)
-        return [];
-    return text.toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, ' ')
-        .split(/\s+/)
-        .filter(w => w.length > 2 && !ROUTING_STOPWORDS.has(w));
-}
-function loadRoutingOutcomes() {
-    try {
-        if (existsSync(getRoutingOutcomesPath())) {
-            const data = JSON.parse(readFileSync(getRoutingOutcomesPath(), 'utf-8'));
-            return data.outcomes || [];
-        }
-    }
-    catch { /* corrupt file, start fresh */ }
-    return [];
-}
-function saveRoutingOutcomes(outcomes) {
-    try {
-        const dir = dirname(getRoutingOutcomesPath());
-        if (!existsSync(dir))
-            mkdirSync(dir, { recursive: true });
-        // Cap at 500 entries to bound file size
-        const capped = outcomes.slice(-500);
-        const tmp = getRoutingOutcomesPath() + '.tmp';
-        writeFileSync(tmp, JSON.stringify({ outcomes: capped }, null, 2));
-        renameSync(tmp, getRoutingOutcomesPath());
-    }
-    catch { /* non-critical */ }
-}
-/**
- * Build learned routing patterns from successful task outcomes.
- * Returns patterns in the same shape as TASK_PATTERNS so they can be
- * merged into both the native HNSW and pure-JS semantic routers.
- */
-function loadLearnedPatterns() {
-    const outcomes = loadRoutingOutcomes();
-    const byAgent = {};
-    for (const o of outcomes) {
-        if (!o.success || !o.agent || !o.keywords?.length)
-            continue;
-        if (!byAgent[o.agent])
-            byAgent[o.agent] = new Set();
-        for (const kw of o.keywords)
-            byAgent[o.agent].add(kw);
-    }
-    const patterns = {};
-    for (const [agent, kwSet] of Object.entries(byAgent)) {
-        patterns[`learned-${agent}`] = {
-            keywords: [...kwSet].slice(0, 50),
-            agents: [agent],
-        };
-    }
-    return patterns;
-}
-/**
- * Merge static TASK_PATTERNS with runtime-learned patterns.
- * Static patterns take precedence (learned patterns won't overwrite them).
- */
-function getMergedTaskPatterns() {
-    const merged = { ...TASK_PATTERNS };
-    const learned = loadLearnedPatterns();
-    for (const [key, pattern] of Object.entries(learned)) {
-        if (!merged[key]) {
-            merged[key] = pattern;
-        }
-    }
-    return merged;
-}
-// ── Static task patterns (used by both native and pure-JS routers) ───
-const TASK_PATTERNS = {
-    'security-task': {
-        keywords: ['authentication', 'security', 'auth', 'password', 'encryption', 'vulnerability', 'cve', 'audit'],
-        agents: ['security-architect', 'security-auditor', 'reviewer'],
-    },
-    'testing-task': {
-        keywords: ['test', 'testing', 'spec', 'coverage', 'unit test', 'integration test', 'e2e'],
-        agents: ['tester', 'reviewer'],
-    },
-    'api-task': {
-        keywords: ['api', 'endpoint', 'rest', 'graphql', 'route', 'handler', 'controller'],
-        agents: ['architect', 'coder', 'tester'],
-    },
-    'performance-task': {
-        keywords: ['performance', 'optimize', 'speed', 'memory', 'benchmark', 'profiling', 'bottleneck'],
-        agents: ['performance-engineer', 'coder', 'tester'],
-    },
-    'refactor-task': {
-        keywords: ['refactor', 'restructure', 'clean', 'organize', 'modular', 'decouple'],
-        agents: ['architect', 'coder', 'reviewer'],
-    },
-    'bugfix-task': {
-        keywords: ['bug', 'fix', 'error', 'issue', 'broken', 'crash', 'debug'],
-        agents: ['coder', 'tester', 'reviewer'],
-    },
-    'feature-task': {
-        keywords: ['feature', 'implement', 'add', 'new', 'create', 'build'],
-        agents: ['architect', 'coder', 'tester'],
-    },
-    'database-task': {
-        keywords: ['database', 'sql', 'query', 'schema', 'migration', 'orm'],
-        agents: ['architect', 'coder', 'tester'],
-    },
-    'frontend-task': {
-        keywords: ['frontend', 'ui', 'component', 'react', 'css', 'style', 'layout'],
-        agents: ['coder', 'reviewer', 'tester'],
-    },
-    'devops-task': {
-        keywords: ['deploy', 'ci', 'cd', 'pipeline', 'docker', 'kubernetes', 'infrastructure'],
-        agents: ['devops', 'coder', 'tester'],
-    },
-    'swarm-task': {
-        keywords: ['swarm', 'agent', 'coordinator', 'hive', 'mesh', 'topology'],
-        agents: ['swarm-specialist', 'coordinator', 'architect'],
-    },
-    'memory-task': {
-        keywords: ['memory', 'cache', 'store', 'vector', 'embedding', 'persistence'],
-        agents: ['memory-specialist', 'architect', 'coder'],
-    },
-};
-// In-memory trajectory tracking (persisted on end)
-const activeTrajectories = new Map();
-const MEMORY_DIR = '.monomind/memory';
-const MEMORY_FILE = 'store.json';
-function getMemoryPath() {
-    return join(getProjectCwd(), MEMORY_DIR, MEMORY_FILE);
-}
-// Maximum size of the legacy JSON memory store before reads are skipped.
-// Matches the guard in memory-tools.ts (loadLegacyStore) which loads the same file.
-const MAX_MEMORY_STORE_BYTES = 50 * 1024 * 1024; // 50 MB
-function loadMemoryStore() {
-    try {
-        const path = getMemoryPath();
-        if (existsSync(path) && statSync(path).size <= MAX_MEMORY_STORE_BYTES) {
-            const data = readFileSync(path, 'utf-8');
-            return JSON.parse(data);
-        }
-    }
-    catch {
-        // Return empty store on error
-    }
-    return { entries: {}, version: '3.0.0' };
-}
-/**
- * Get real intelligence statistics from memory store
- */
-function getIntelligenceStatsFromMemory() {
-    const store = loadMemoryStore();
-    const entries = Object.values(store.entries);
-    // Count trajectories (keys starting with "trajectory-" or containing trajectory data)
-    const trajectoryEntries = entries.filter(e => e.key.includes('trajectory') ||
-        (e.metadata?.type === 'trajectory'));
-    const successfulTrajectories = trajectoryEntries.filter(e => e.metadata?.success === true ||
-        (typeof e.value === 'object' && e.value !== null && e.value.success === true));
-    // Count patterns
-    const patternEntries = entries.filter(e => e.key.includes('pattern') ||
-        e.metadata?.type === 'pattern' ||
-        e.key.startsWith('learned-'));
-    // Categorize patterns
-    const categories = {};
-    patternEntries.forEach(e => {
-        const category = e.metadata?.category || 'general';
-        categories[category] = (categories[category] || 0) + 1;
-    });
-    // Count routing decisions
-    const routingEntries = entries.filter(e => e.key.includes('routing') ||
-        e.metadata?.type === 'routing-decision');
-    // Calculate average confidence from routing decisions
-    let totalConfidence = 0;
-    let confidenceCount = 0;
-    routingEntries.forEach(e => {
-        const confidence = e.metadata?.confidence;
-        if (typeof confidence === 'number') {
-            totalConfidence += confidence;
-            confidenceCount++;
-        }
-    });
-    // Calculate total access count
-    const totalAccessCount = entries.reduce((sum, e) => sum + (e.accessCount || 0), 0);
-    // Calculate memory file size
-    let memorySizeBytes = 0;
-    try {
-        const memPath = getMemoryPath();
-        if (existsSync(memPath)) {
-            memorySizeBytes = statSync(memPath).size;
-        }
-    }
-    catch {
-        // Ignore
-    }
-    return {
-        trajectories: {
-            total: trajectoryEntries.length,
-            successful: successfulTrajectories.length,
-        },
-        patterns: {
-            learned: patternEntries.length,
-            categories,
-        },
-        memory: {
-            indexSize: entries.length,
-            totalAccessCount,
-            memorySizeBytes,
-        },
-        routing: {
-            decisions: routingEntries.length,
-            avgConfidence: confidenceCount > 0 ? totalConfidence / confidenceCount : 0,
-        },
-    };
-}
-// 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'],
-};
-// Keyword patterns for fallback routing (when semantic routing doesn't match)
-const KEYWORD_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();
-    // Check static keyword patterns first
-    for (const [pattern, result] of Object.entries(KEYWORD_PATTERNS)) {
-        if (taskLower.includes(pattern)) {
-            return result;
-        }
-    }
-    // Check runtime-learned patterns from successful task outcomes
-    const taskKeywords = extractKeywords(task);
-    if (taskKeywords.length > 0) {
-        const outcomes = loadRoutingOutcomes();
-        let bestAgent = '';
-        let bestOverlap = 0;
-        for (const outcome of outcomes) {
-            if (!outcome.success || !outcome.agent || !outcome.keywords?.length)
-                continue;
-            const overlap = taskKeywords.filter(kw => outcome.keywords.includes(kw)).length;
-            if (overlap > bestOverlap) {
-                bestOverlap = overlap;
-                bestAgent = outcome.agent;
-            }
-        }
-        // Require at least 2 keyword overlap to prevent false positives
-        if (bestAgent && bestOverlap >= 2) {
-            return { agents: [bestAgent], confidence: Math.min(0.6 + bestOverlap * 0.05, 0.85) };
-        }
-    }
-    // Default fallback
-    return { agents: ['coder', 'researcher', 'tester'], confidence: 0.7 };
-}
-/**
- * V3: Augment agent suggestions with semantic matches from intelligence.ts ReasoningBank.
- * Returns null when the intelligence system is unavailable or has no relevant patterns.
- * Kept sync-safe by returning a Promise — callers that need a sync result use the
- * non-async suggestAgentsForTask above and optionally merge async results.
- */
-// Canonical set of valid monomind agent type strings.
-// Patterns whose type is not in this set (e.g. 'action', 'observation', 'routing')
-// are structural labels, not agent names, and must be excluded from routing.
-//
-// Lean teardown: the SONA neural LoRA routing adaptation (applyNeuralAdaptation +
-// the @monomind/neural NeuralLearningSystem singleton) has been removed. Routing now
-// uses the pure keyword path plus the deterministic generateSimpleEmbedding query
-// against the pattern index, with outcomes recorded via route-outcomes. No ONNX /
-// LoRA inference happens on the routing hot path anymore.
-const VALID_AGENT_TYPES = new Set([
-    'coder', 'reviewer', 'tester', 'planner', 'researcher',
-    'architect', 'security-architect', 'security-auditor',
-    'performance-engineer', 'backend-dev', 'mobile-dev',
-    'ml-developer', 'cicd-engineer', 'api-docs', 'system-architect',
-    'code-analyzer', 'devops', 'debugger', 'documenter', 'optimizer',
-]);
-async function suggestAgentsFromIntelligence(task) {
-    try {
-        const intel = await import('../memory/intelligence.js');
-        await intel.initializeIntelligence();
-        const matches = await intel.findSimilarPatterns(task, { k: 5 });
-        if (!matches || matches.length === 0)
-            return null;
-        // Only count patterns whose type is a valid agent name.
-        // Trajectory-derived patterns use type='action'|'observation' etc. — skip those.
-        const agentCounts = {};
-        for (const m of matches) {
-            const agent = m.type ?? '';
-            if (!VALID_AGENT_TYPES.has(agent))
-                continue;
-            agentCounts[agent] = (agentCounts[agent] ?? 0) + (m.similarity ?? m.confidence ?? 0.5);
-        }
-        const sorted = Object.entries(agentCounts).sort((a, b) => b[1] - a[1]);
-        if (sorted.length === 0)
-            return null;
-        // Return top-3 ranked agents so callers can build multi-agent task assignments
-        const topAgents = sorted.slice(0, 3).map(([agent]) => agent);
-        const confidence = Math.min(0.9, sorted[0][1] / matches.length);
-        return { agents: topAgents, confidence };
-    }
-    catch {
-        return null;
-    }
-}
-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) => {
-        // Cap filePath: passed to suggestAgentsForFile (O(n) regex) and reflected in
-        // response.  Cap operation to prevent oversized strings in recommendations.
-        const MAX_PRE_EDIT_PATH_LEN = 4 * 1024;
-        const MAX_PRE_EDIT_OP_LEN = 64;
-        const rawFilePath = params.filePath;
-        const filePath = typeof rawFilePath === 'string' && rawFilePath.length > MAX_PRE_EDIT_PATH_LEN
-            ? rawFilePath.slice(0, MAX_PRE_EDIT_PATH_LEN)
-            : rawFilePath;
-        const rawOperation = params.operation || 'update';
-        const operation = typeof rawOperation === 'string' && rawOperation.length > MAX_PRE_EDIT_OP_LEN
-            ? rawOperation.slice(0, MAX_PRE_EDIT_OP_LEN)
-            : rawOperation;
-        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) => {
-        // Cap filePath: interpolated into taskId and task text forwarded to
-        // bridgeRecordFeedback (which calls generateEmbedding — O(n) hash fallback).
-        // Cap agent: stored in feedback record and forwarded to bridge.
-        const MAX_POST_EDIT_PATH_LEN = 4 * 1024;
-        const MAX_POST_EDIT_AGENT_LEN = 256;
-        const rawFilePath = params.filePath;
-        const filePath = typeof rawFilePath === 'string' && rawFilePath.length > MAX_POST_EDIT_PATH_LEN
-            ? rawFilePath.slice(0, MAX_POST_EDIT_PATH_LEN)
-            : rawFilePath;
-        const success = params.success !== false;
-        const rawAgent = params.agent;
-        const agent = typeof rawAgent === 'string' && rawAgent.length > MAX_POST_EDIT_AGENT_LEN
-            ? rawAgent.slice(0, MAX_POST_EDIT_AGENT_LEN)
-            : rawAgent;
-        // Wire recordFeedback through bridge (issue #1209)
-        let feedbackResult = null;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            feedbackResult = await bridge.bridgeRecordFeedback({
-                taskId: `edit-${filePath}-${Date.now()}`,
-                success,
-                quality: success ? 0.85 : 0.3,
-                agent,
-                // B1.2: give the SONA embedder real semantics (the edited file) instead of
-                // the opaque task ID.
-                task: `edit ${filePath}`,
-            });
-        }
-        catch {
-            // Bridge not available — continue with basic response
-        }
-        return {
-            recorded: true,
-            filePath,
-            success,
-            timestamp: new Date().toISOString(),
-            learningUpdate: success ? 'pattern_reinforced' : 'pattern_adjusted',
-            feedback: feedbackResult ? {
-                recorded: feedbackResult.success,
-                controller: feedbackResult.controller,
-                updates: feedbackResult.updated,
-            } : { recorded: false, controller: 'unavailable', updates: 0 },
-        };
-    },
-};
-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) => {
-        // Cap command length: assessCommandRisk runs O(n) string searches, and the
-        // raw command is reflected verbatim in the response.  Limit to 4 KB which
-        // is far beyond any realistic shell command.
-        const MAX_CMD_LEN = 4 * 1024;
-        const rawCommand = params.command;
-        const command = typeof rawCommand === 'string' && rawCommand.length > MAX_CMD_LEN
-            ? rawCommand.slice(0, MAX_CMD_LEN)
-            : rawCommand;
-        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) => {
-        // Cap command: it is stored in JSON memory store (line 824), forwarded to
-        // bridgeStoreEntry which calls generateEmbedding by default — O(n) hash
-        // fallback, and reflected verbatim in the response.  The recordCommand path
-        // already caps to 200 chars; apply a consistent 4 KB cap here that still
-        // covers any realistic shell command.
-        const MAX_POST_CMD_LEN = 4 * 1024;
-        const rawPostCommand = params.command;
-        const command = typeof rawPostCommand === 'string' && rawPostCommand.length > MAX_POST_CMD_LEN
-            ? rawPostCommand.slice(0, MAX_POST_CMD_LEN)
-            : rawPostCommand;
-        const exitCode = params.exitCode || 0;
-        const success = exitCode === 0;
-        // Record the real exit code in the time-windowed command-outcome store so
-        // post-task can derive a MEASURED success signal (grounded in actual exit
-        // codes) when the caller does not explicitly assert --success. Non-fatal.
-        await recordCommand(getRouteOutcomesBaseDir(), {
-            ts: Date.now(),
-            command: typeof command === 'string' ? command.slice(0, 200) : String(command).slice(0, 200),
-            exitCode,
-        });
-        // Persist command outcome via AgentDB
-        let _storedIn = 'none';
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            await bridge.bridgeStoreEntry({
-                key: `cmd-${Date.now()}`,
-                value: JSON.stringify({ command, exitCode, success }),
-                namespace: 'commands',
-                tags: [success ? 'success' : 'error'],
-            });
-            _storedIn = 'agentdb';
-        }
-        catch {
-            // AgentDB not available — store in JSON
-            try {
-                const store = loadMemoryStore();
-                const key = `cmd-${Date.now()}`;
-                store.entries[key] = { key, value: JSON.stringify({ command, exitCode, success }), namespace: 'commands', createdAt: new Date().toISOString() };
-                const memDir = join(getProjectCwd(), MEMORY_DIR);
-                if (!existsSync(memDir))
-                    mkdirSync(memDir, { recursive: true });
-                const _mp = getMemoryPath();
-                const _mptmp = _mp + '.tmp';
-                writeFileSync(_mptmp, JSON.stringify(store, null, 2), 'utf-8');
-                renameSync(_mptmp, _mp);
-                _storedIn = 'json-store';
-            }
-            catch { /* non-critical */ }
-        }
-        return {
-            recorded: _storedIn !== 'none',
-            command,
-            exitCode,
-            success,
-            timestamp: new Date().toISOString(),
-            _storedIn,
-        };
-    },
-};
-export const hooksRoute = {
-    name: 'hooks_route',
-    description: 'Route task to optimal agent using semantic similarity (native HNSW or pure JS)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            task: { type: 'string', description: 'Task description' },
-            context: { type: 'string', description: 'Additional context' },
-            useSemanticRouter: { type: 'boolean', description: 'Use semantic similarity routing (default: true)' },
-        },
-        required: ['task'],
-    },
-    handler: async (params) => {
-        // Cap task and context lengths: both are forwarded to generateEmbedding
-        // via bridgeRouteTask, and task is used in extractKeywords + stored in
-        // route-outcomes.jsonl.  16 KB matches the cap in hooksPatternSearch.
-        const MAX_ROUTE_TASK_LEN = 16 * 1024;
-        const MAX_ROUTE_CTX_LEN = 4 * 1024;
-        const rawTask = params.task;
-        const task = typeof rawTask === 'string' && rawTask.length > MAX_ROUTE_TASK_LEN
-            ? rawTask.slice(0, MAX_ROUTE_TASK_LEN)
-            : rawTask;
-        const rawContext = params.context;
-        const context = typeof rawContext === 'string' && rawContext.length > MAX_ROUTE_CTX_LEN
-            ? rawContext.slice(0, MAX_ROUTE_CTX_LEN)
-            : rawContext;
-        const useSemanticRouter = params.useSemanticRouter !== false;
-        // Phase 5: Try AgentDB's SemanticRouter / LearningSystem first
-        if (useSemanticRouter) {
-            try {
-                const bridge = await import('../memory/memory-bridge.js');
-                const agentdbRoute = await bridge.bridgeRouteTask({ task, context });
-                if (agentdbRoute && agentdbRoute.confidence > 0.5) {
-                    const agents = agentdbRoute.agents.length > 0 ? agentdbRoute.agents : ['coder', 'researcher'];
-                    const complexity = task.length > 200 ? 'high' : task.length < 50 ? 'low' : 'medium';
-                    const agentdbMethod = `agentdb-${agentdbRoute.controller}`;
-                    const agentdbConfidence = Math.round(agentdbRoute.confidence * 100) / 100;
-                    // Record the route recommendation so post-task can join the actual outcome
-                    const routeId = randomUUID();
-                    await recordRoute(getRouteOutcomesBaseDir(), {
-                        routeId,
-                        ts: Date.now(),
-                        task,
-                        recommendedAgent: agents[0],
-                        routingMethod: agentdbMethod,
-                        confidence: agentdbConfidence,
-                        learningMode: 'js',
-                    });
-                    return {
-                        routeId,
-                        task,
-                        routing: {
-                            method: agentdbMethod,
-                            backend: agentdbRoute.controller,
-                            latencyMs: 0,
-                            throughput: 'N/A',
-                        },
-                        matchedPattern: agentdbRoute.route,
-                        semanticMatches: [{ pattern: agentdbRoute.route, score: agentdbRoute.confidence }],
-                        primaryAgent: {
-                            type: agents[0],
-                            confidence: Math.round(agentdbRoute.confidence * 100) / 100,
-                            reason: `AgentDB ${agentdbRoute.controller}: "${agentdbRoute.route}" (${Math.round(agentdbRoute.confidence * 100)}%)`,
-                        },
-                        alternativeAgents: agents.slice(1).map((agent, i) => ({
-                            type: agent,
-                            confidence: Math.round((agentdbRoute.confidence - (0.1 * (i + 1))) * 100) / 100,
-                            reason: `Alternative from ${agentdbRoute.controller}`,
-                        })),
-                        estimatedMetrics: {
-                            successProbability: Math.round(agentdbRoute.confidence * 100) / 100,
-                            estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-                            complexity,
-                        },
-                        swarmRecommendation: agents.length > 2 ? { topology: 'hierarchical', agents, coordination: 'queen-led' } : null,
-                    };
-                }
-            }
-            catch {
-                // AgentDB router not available — fall through to local routing
-            }
-        }
-        // Deterministic keyword routing is the baseline (and only) local path.
-        const semanticResult = [];
-        let routingMethod = 'keyword';
-        const routingLatencyMs = 0;
-        let backendInfo = '';
-        // Get agents from keyword routing
-        let agents;
-        let confidence;
-        let matchedPattern = '';
-        {
-            // Keyword fallback is the baseline
-            const keywordSuggestion = suggestAgentsForTask(task);
-            agents = keywordSuggestion.agents;
-            confidence = keywordSuggestion.confidence;
-            matchedPattern = 'keyword-fallback';
-            routingMethod = 'keyword';
-            backendInfo = 'keyword matching';
-            // V3: augment with neural ReasoningBank patterns — merge into agent list
-            // rather than replacing, so keyword precision is preserved while neural
-            // adds learned agents from past sessions.
-            const intelSuggestion = await suggestAgentsFromIntelligence(task).catch(() => null);
-            if (intelSuggestion && intelSuggestion.confidence > 0.5) {
-                // Prepend neural agents (deduped) and boost confidence
-                const existingSet = new Set(agents);
-                const neuralOnly = intelSuggestion.agents.filter(a => !existingSet.has(a));
-                agents = [...intelSuggestion.agents, ...agents.filter(a => !new Set(intelSuggestion.agents).has(a))];
-                const neuralWeight = intelSuggestion.confidence > 0.7 ? 0.65 : 0.5;
-                const keywordWeight = 1 - neuralWeight;
-                confidence = Math.min(0.95, intelSuggestion.confidence * neuralWeight +
-                    confidence * keywordWeight +
-                    (neuralOnly.length > 0 ? 0.03 : 0));
-                matchedPattern = 'neural+keyword';
-                routingMethod = 'neural-augmented';
-                backendInfo = 'intelligence ReasoningBank + keyword matching';
-            }
-        }
-        // Determine complexity
-        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';
-        const primaryConfidence = Math.round(confidence * 100) / 100;
-        // Record the route recommendation so post-task can join the actual outcome
-        const routeId = randomUUID();
-        await recordRoute(getRouteOutcomesBaseDir(), {
-            routeId,
-            ts: Date.now(),
-            task,
-            recommendedAgent: agents[0],
-            routingMethod,
-            confidence: primaryConfidence,
-            learningMode: 'js',
-        });
-        return {
-            routeId,
-            task,
-            routing: {
-                method: routingMethod,
-                backend: backendInfo,
-                latencyMs: routingLatencyMs,
-                throughput: routingLatencyMs > 0 ? `${Math.round(1000 / routingLatencyMs)} routes/s` : 'N/A',
-            },
-            matchedPattern,
-            semanticMatches: semanticResult.slice(0, 3).map(r => ({
-                pattern: r.intent,
-                score: Math.round(r.score * 100) / 100,
-            })),
-            primaryAgent: {
-                type: agents[0],
-                confidence: Math.round(confidence * 100) / 100,
-                reason: routingMethod.startsWith('semantic')
-                    ? `Semantic similarity to "${matchedPattern}" pattern (${Math.round(confidence * 100)}%)`
-                    : `Task contains keywords matching ${agents[0]} specialization`,
-            },
-            alternativeAgents: agents.slice(1).map((agent, i) => ({
-                type: agent,
-                confidence: Math.round((confidence - (0.1 * (i + 1))) * 100) / 100,
-                reason: `Alternative agent for ${agent} capabilities`,
-            })),
-            estimatedMetrics: {
-                successProbability: Math.round(confidence * 100) / 100,
-                estimatedDuration: complexity === 'high' ? '2-4 hours' : complexity === 'medium' ? '30-60 min' : '10-30 min',
-                complexity,
-            },
-            swarmRecommendation: agents.length > 2 ? {
-                topology: 'hierarchical',
-                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)' },
-            includeV1: { type: 'boolean', description: 'Include v1 performance metrics' },
-        },
-    },
-    handler: async (params) => {
-        const period = params.period || '24h';
-        // Try to read real counts from memory store
-        const store = loadMemoryStore();
-        const entries = Object.values(store.entries);
-        // Count patterns by looking at stored pattern entries
-        const patternEntries = entries.filter(e => e.key.includes('pattern'));
-        const routingEntries = entries.filter(e => e.key.includes('route') || e.key.includes('routing'));
-        const taskEntries = entries.filter(e => e.key.includes('task'));
-        if (entries.length === 0) {
-            return {
-                _real: true,
-                _note: 'No metrics data collected yet. Data populates from hooks_post-task, hooks_post-edit, hooks_post-command, and hooks_route calls.',
-                period,
-                patterns: { total: 0, successful: 0, failed: 0, avgConfidence: null },
-                agents: { routingAccuracy: null, totalRoutes: 0, topAgent: null },
-                commands: { totalExecuted: 0, successRate: null, avgRiskScore: null },
-                lastUpdated: new Date().toISOString(),
-            };
-        }
-        return {
-            period,
-            patterns: {
-                total: patternEntries.length,
-                successful: null,
-                failed: null,
-                avgConfidence: null,
-            },
-            agents: {
-                routingAccuracy: null,
-                totalRoutes: routingEntries.length,
-                topAgent: null,
-            },
-            commands: {
-                totalExecuted: taskEntries.length,
-                successRate: null,
-                avgRiskScore: null,
-            },
-            dataSource: 'memory-store',
-            entriesFound: entries.length,
-            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 with intelligent model routing (ADR-026)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            taskId: { type: 'string', description: 'Task identifier' },
-            description: { type: 'string', description: 'Task description' },
-            filePath: { type: 'string', description: 'Optional file path for AST analysis' },
-        },
-        required: ['taskId', 'description'],
-    },
-    handler: async (params) => {
-        // Cap taskId: it is used as a suffix in SQLite memory keys (heuristic:${taskId},
-        // routing-decision:${taskId}, textual_gradient:${taskId}) and as sourceId/targetId
-        // in causal-graph edges persisted to SQLite. An uncapped ID can inflate the DB key
-        // column and every JSON payload that includes the ID.
-        const MAX_TASK_ID_LEN = 256;
-        const rawTaskId = params.taskId;
-        const taskId = typeof rawTaskId === 'string' && rawTaskId.length > MAX_TASK_ID_LEN
-            ? rawTaskId.slice(0, MAX_TASK_ID_LEN)
-            : rawTaskId;
-        // Cap description: it is forwarded to generateEmbedding twice (ERL heuristics
-        // + TextGrad gradient queries) and used in O(n) keyword extraction.
-        // 16 KB matches the cap applied in hooks_route and hooksPatternSearch.
-        const MAX_PRE_TASK_DESC_LEN = 16 * 1024;
-        const rawDescription = params.description;
-        const description = typeof rawDescription === 'string' && rawDescription.length > MAX_PRE_TASK_DESC_LEN
-            ? rawDescription.slice(0, MAX_PRE_TASK_DESC_LEN)
-            : rawDescription;
-        const filePath = params.filePath;
-        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';
-        // Enhanced model routing module was never shipped — modelRouting stays undefined.
-        const modelRouting = undefined;
-        // ERL: Retrieve past heuristics to inject into recommendations
-        // Source: https://arxiv.org/abs/2603.24639
-        const erlHints = [];
-        try {
-            const searchFn = await getRealSearchFunction();
-            if (searchFn) {
-                const heuristicResults = await searchFn({
-                    query: description,
-                    namespace: 'heuristics',
-                    limit: 3,
-                    threshold: 0.6,
-                });
-                for (const r of (heuristicResults?.results ?? [])) {
-                    try {
-                        const h = JSON.parse(r.content ?? '{}');
-                        if (h.action && h.confidence !== undefined && h.confidence >= 0.6) {
-                            erlHints.push(`ERL hint (conf=${h.confidence.toFixed(2)}): use "${h.action}" for tasks involving "${h.condition ?? 'similar context'}"`);
-                        }
-                    }
-                    catch { /* skip malformed */ }
-                }
-                // TextGrad: also inject relevant past failure gradients to guide away from known pitfalls
-                // Source: https://arxiv.org/abs/2406.07496
-                const gradientResults = await searchFn({
-                    query: description,
-                    namespace: 'gradients',
-                    limit: 2,
-                    threshold: 0.55,
-                });
-                for (const r of (gradientResults?.results ?? [])) {
-                    const critique = r.content ?? '';
-                    if (critique && critique.length > 10) {
-                        erlHints.push(`TextGrad warning: ${critique.slice(0, 120)}`);
-                    }
-                }
-            }
-        }
-        catch { /* non-critical */ }
-        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',
-                ...erlHints,
-            ],
-            modelRouting,
-            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)' },
-            task: { type: 'string', description: 'Task description text (used for learning keyword extraction)' },
-            storeDecisions: { type: 'boolean', description: 'Also store routing decision in memory DB' },
-            routeId: { type: 'string', description: 'Route ID from a prior hooks_route call — joins the recommendation to this outcome' },
-        },
-        required: ['taskId'],
-    },
-    handler: async (params) => {
-        // Cap taskId for the same reason as hooks_pre_task: it flows into SQLite memory keys
-        // (heuristic:${taskId}, routing-decision:${taskId}, textual_gradient:${taskId}) and
-        // into causal-graph edge IDs persisted to the DB.  Without a cap an attacker can
-        // inflate every row that stores the raw ID.
-        const MAX_POST_TASK_ID_LEN = 256;
-        const rawPostTaskId = params.taskId;
-        const taskId = typeof rawPostTaskId === 'string' && rawPostTaskId.length > MAX_POST_TASK_ID_LEN
-            ? rawPostTaskId.slice(0, MAX_POST_TASK_ID_LEN)
-            : rawPostTaskId;
-        // The success flag, when the caller asserts it (--success true), is taken as
-        // ground truth. But callers usually do NOT pass it. Rather than treating every
-        // unverified task as "unknown" (and thus excluding it from learning), we now
-        // derive a MEASURED success signal from the real command exit codes recorded by
-        // post-command within a recent time window. post-command appends each exit code
-        // to the command-outcome store keyed by timestamp; deriveRecentSuccess returns:
-        //   true  → recent commands exist and the LAST command exited 0 (final-state heuristic)
-        //   false → recent commands exist and the LAST command exited non-zero
-        //   null  → no recent commands (genuinely no signal → stays unknown)
-        // Note: "final-state" not "all must pass" — intermediate failures (e.g. grep no-match,
-        // test-then-fix cycles) are intentionally ignored; the last exit code decides.
-        // Precedence: an explicit --success ALWAYS wins; the derived signal only fills
-        // in when no explicit flag is given; only when there is also no recent command
-        // signal does the outcome stay unknown (and excluded from SONA + route join,
-        // per the existing "unknown ≠ success" principle).
-        const explicitSuccess = typeof params.success === 'boolean';
-        let outcomeKnown = explicitSuccess;
-        let success = params.success !== false;
-        let successSource = explicitSuccess ? 'explicit' : 'unknown';
-        if (!explicitSuccess) {
-            const derived = await deriveRecentSuccess(getRouteOutcomesBaseDir());
-            if (derived !== null) {
-                outcomeKnown = true;
-                success = derived;
-                successSource = 'derived-commands';
-            }
-        }
-        // Cap agent: forwarded to bridgeRecordFeedback where it is stored in the
-        // feedback record and used as a tag string in the JSON store.  An uncapped
-        // agent value inflates the on-disk store entry.
-        const MAX_POST_TASK_AGENT_LEN = 256;
-        const rawPostTaskAgent = params.agent;
-        const agent = typeof rawPostTaskAgent === 'string' && rawPostTaskAgent.length > MAX_POST_TASK_AGENT_LEN
-            ? rawPostTaskAgent.slice(0, MAX_POST_TASK_AGENT_LEN)
-            : rawPostTaskAgent;
-        const quality = params.quality || (success ? 0.85 : 0.3);
-        const startTime = Date.now();
-        // Cap task description: passed to generateEmbedding via bridgeRecordFeedback
-        // and persisted to route-outcomes.jsonl.  16 KB matches hooks_route cap.
-        const MAX_POST_TASK_LEN = 16 * 1024;
-        const rawPostTask = params.task;
-        const cappedPostTask = typeof rawPostTask === 'string' && rawPostTask.length > MAX_POST_TASK_LEN
-            ? rawPostTask.slice(0, MAX_POST_TASK_LEN)
-            : rawPostTask;
-        // Phase 3: Wire recordFeedback through bridge → LearningSystem + ReasoningBank
-        let feedbackResult = null;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            feedbackResult = await bridge.bridgeRecordFeedback({
-                taskId,
-                success,
-                quality,
-                agent,
-                // B1.2: thread the real task description into the SONA trajectory so the
-                // embedder encodes meaning, not the opaque task ID.
-                task: cappedPostTask || undefined,
-                // B1.3: only feed the SONA LoRA update when the outcome is actually known.
-                outcomeKnown,
-                duration: params.duration || undefined,
-                patterns: params.patterns || undefined,
-            });
-        }
-        catch {
-            // Bridge not available — continue with basic response
-        }
-        // Phase 3: Record causal edge (task → outcome)
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            await bridge.bridgeRecordCausalEdge({
-                sourceId: taskId,
-                targetId: `outcome-${taskId}`,
-                relation: success ? 'succeeded' : 'failed',
-                weight: quality,
-            });
-        }
-        catch {
-            // Non-fatal
-        }
-        // Persist routing outcome for runtime learning (file-based, always reliable).
-        // B1.3: also gate this sibling learning sink on a known outcome — an unverified
-        // task must not train the router as a success either. When the caller did not
-        // assert success, the outcome is unknown and we skip persisting a labeled sample.
-        const taskText = cappedPostTask || '';
-        const outcomeKeywords = extractKeywords(taskText);
-        let outcomePersisted = false;
-        if (outcomeKnown && taskText && agent && agent.length <= 100 && /^[a-zA-Z0-9_-]+$/.test(agent)) {
-            try {
-                const outcomes = loadRoutingOutcomes();
-                outcomes.push({
-                    task: taskText,
-                    agent,
-                    success,
-                    quality,
-                    keywords: outcomeKeywords,
-                    timestamp: new Date().toISOString(),
-                });
-                saveRoutingOutcomes(outcomes);
-                outcomePersisted = true;
-            }
-            catch { /* non-critical */ }
-        }
-        // Join this outcome back onto the original route recommendation. This is the
-        // recommendation→actual→success link that routing-accuracy metrics and SONA
-        // labels depend on. When the caller threads an explicit routeId we join that
-        // record; otherwise we auto-correlate to the most recent unresolved route
-        // (within a 10-min window) so the loop closes without the LLM manually
-        // threading the routeId. Only join when the outcome is actually measured —
-        // per "unknown ≠ success", an unverified task must not pollute the metric.
-        if (outcomeKnown) {
-            const outcome = {
-                agentActuallyUsed: agent,
-                measuredSuccess: success,
-                quality: typeof params.quality === 'number' ? params.quality : undefined,
-            };
-            if (params.routeId) {
-                await joinOutcome(getRouteOutcomesBaseDir(), params.routeId, outcome);
-            }
-            else {
-                await joinLatestUnresolved(getRouteOutcomesBaseDir(), outcome);
-            }
-        }
-        // ERL: Extract and persist structured heuristic for future pre-task injection
-        // Source: https://arxiv.org/abs/2603.24639
-        if (taskText && agent && success !== undefined) {
-            try {
-                const storeFn = await getRealStoreFunction();
-                if (storeFn) {
-                    const heuristic = {
-                        condition: outcomeKeywords.slice(0, 3).join(', ') || taskText.slice(0, 60),
-                        action: agent,
-                        confidence: success ? (quality ?? 0.8) : 0.2,
-                    };
-                    await storeFn({
-                        key: `heuristic:${taskId}`,
-                        value: JSON.stringify(heuristic),
-                        namespace: 'heuristics',
-                        tags: ['erl', agent, success ? 'success' : 'failure'],
-                    });
-                }
-            }
-            catch { /* non-critical */ }
-        }
-        // Optionally store in memory DB for cross-session vector retrieval
-        if (params.storeDecisions && taskText && agent) {
-            try {
-                const storeFn = await getRealStoreFunction();
-                if (storeFn) {
-                    await storeFn({
-                        key: `routing-decision:${taskId}`,
-                        namespace: 'patterns',
-                        value: JSON.stringify({ task: taskText, agent, success, quality, keywords: outcomeKeywords }),
-                        tags: ['routing-decision'],
-                    });
-                }
-            }
-            catch { /* non-critical */ }
-        }
-        const duration = Date.now() - startTime;
-        // TextGrad: Store textual gradient critique for failed tasks
-        // Source: https://arxiv.org/abs/2406.07496 (TextGrad — Nature)
-        if (!success && taskText) {
-            try {
-                const storeFn = await getRealStoreFunction();
-                if (storeFn) {
-                    const critique = `Task "${taskText.slice(0, 80)}" failed with agent "${agent}". ` +
-                        `Quality score: ${quality ?? 'unknown'}. ` +
-                        `Improvement direction: review agent selection, consider more capable agent or task decomposition.`;
-                    await storeFn({
-                        key: `textual_gradient:${taskId}`,
-                        value: critique,
-                        namespace: 'gradients',
-                        tags: ['textual_gradient', agent ?? 'unknown', 'failure'],
-                    });
-                }
-            }
-            catch { /* non-critical */ }
-        }
-        // MAR: Structured multi-agent reflection on failure
-        // Source: https://arxiv.org/html/2512.20845 (MAR — December 2025)
-        const marReflection = !success ? {
-            needed: true,
-            suggestedAgents: [
-                { role: 'diagnoser', description: 'Analyze root cause of task failure' },
-                { role: 'critic-1', description: 'Critique from correctness angle (temperature 0.3)' },
-                { role: 'critic-2', description: 'Critique from efficiency angle (temperature 0.8)' },
-                { role: 'aggregator', description: 'Synthesize critiques into actionable reflection heuristic' },
-            ],
-            storeAs: 'heuristics',
-            note: 'Spawn agents sequentially: Diagnoser → Critics in parallel → Aggregator',
-        } : { needed: false };
-        return {
-            taskId,
-            success,
-            outcomeKnown,
-            successSource,
-            duration,
-            learningUpdates: {
-                patternsUpdated: feedbackResult?.updated || (success ? 2 : 1),
-                newPatterns: success ? 1 : 0,
-                trajectoryId: `traj-${Date.now()}`,
-                controller: feedbackResult?.controller || 'none',
-                outcomePersisted,
-            },
-            quality,
-            feedback: feedbackResult ? {
-                recorded: feedbackResult.success,
-                controller: feedbackResult.controller,
-                updates: feedbackResult.updated,
-            } : { recorded: false, controller: 'unavailable', updates: 0 },
-            marReflection,
-            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) => {
-        // Cap task: forwarded to suggestAgentsForTask (O(n) keyword loop + extractKeywords),
-        // .toLowerCase() (O(n)), and reflected verbatim in the response.
-        const MAX_EXPLAIN_TASK_LEN = 16 * 1024;
-        const rawExplainTask = params.task;
-        const task = typeof rawExplainTask === 'string' && rawExplainTask.length > MAX_EXPLAIN_TASK_LEN
-            ? rawExplainTask.slice(0, MAX_EXPLAIN_TASK_LEN)
-            : rawExplainTask;
-        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: pattern.length / Math.max(taskLower.length, 1), // real ratio: pattern length vs task length
-                    examples: [`Keyword "${pattern}" matched in task description`],
-                });
-            }
-        }
-        // Calculate real historical success rate from routing outcomes file
-        let historicalSuccess = null;
-        let historicalNote = 'No historical data yet';
-        try {
-            const outcomesPath = getRoutingOutcomesPath();
-            if (existsSync(outcomesPath)) {
-                const data = JSON.parse(readFileSync(outcomesPath, 'utf-8'));
-                const outcomes = data.outcomes || [];
-                if (outcomes.length > 0) {
-                    historicalSuccess = outcomes.filter(o => o.success).length / outcomes.length;
-                    historicalNote = `Calculated from ${outcomes.length} recorded outcomes`;
-                }
-            }
-        }
-        catch {
-            // File unreadable; leave as null
-        }
-        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: historicalSuccess, impact: historicalNote },
-                { factor: 'Agent Availability', weight: 0.2, value: null, impact: 'Agent availability tracking not implemented' },
-                { 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`,
-                    historicalSuccess !== null
-                        ? `Historical success rate for similar tasks: ${(historicalSuccess * 100).toFixed(0)}%`
-                        : `No historical outcome data available yet`,
-                    `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 repoPath = resolve(params.path || '.');
-        const projectRoot = getProjectCwd();
-        if (repoPath !== projectRoot && !repoPath.startsWith(projectRoot + sep)) {
-            return { error: 'Invalid path: must be within the project directory.' };
-        }
-        const depth = params.depth || 'medium';
-        const startTime = performance.now();
-        // Real file scanning — count files by extension, extract patterns
-        const { readdirSync, statSync } = await import('node:fs');
-        const extCounts = {};
-        let filesAnalyzed = 0;
-        let totalLines = 0;
-        const maxDepth = depth === 'shallow' ? 2 : depth === 'deep' ? 6 : 4;
-        const patterns = [];
-        const scan = (dir, currentDepth) => {
-            if (currentDepth > maxDepth)
-                return;
-            try {
-                const entries = readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist')
-                        continue;
-                    const full = join(dir, entry.name);
-                    if (entry.isDirectory()) {
-                        scan(full, currentDepth + 1);
-                    }
-                    else if (entry.isFile()) {
-                        const ext = entry.name.includes('.') ? entry.name.slice(entry.name.lastIndexOf('.')) : '';
-                        if (ext)
-                            extCounts[ext] = (extCounts[ext] || 0) + 1;
-                        filesAnalyzed++;
-                        // For code files, count lines and extract imports
-                        if (['.ts', '.js', '.py', '.go', '.rs', '.java'].includes(ext)) {
-                            try {
-                                // Skip very large files (minified bundles, generated code) to prevent OOM.
-                                // 1 MB is generous for a source file; anything larger is unlikely to have
-                                // useful import patterns in the first 30 lines anyway.
-                                const MAX_CODE_FILE_BYTES = 1 * 1024 * 1024;
-                                if (statSync(full).size > MAX_CODE_FILE_BYTES)
-                                    continue;
-                                const content = readFileSync(full, 'utf-8');
-                                const lines = content.split('\n');
-                                totalLines += lines.length;
-                                // Extract import patterns (first 50 files max for performance)
-                                if (filesAnalyzed <= 50) {
-                                    for (const line of lines.slice(0, 30)) {
-                                        if (line.startsWith('import ') || line.startsWith('from ') || line.startsWith('const ') && line.includes('require(')) {
-                                            const trimmed = line.trim();
-                                            if (trimmed.length < 120 && !patterns.includes(trimmed))
-                                                patterns.push(trimmed);
-                                            if (patterns.length >= 100)
-                                                break;
-                                        }
-                                    }
-                                }
-                            }
-                            catch { /* skip unreadable */ }
-                        }
-                    }
-                }
-            }
-            catch { /* skip inaccessible dirs */ }
-        };
-        scan(repoPath, 0);
-        const elapsed = Math.round(performance.now() - startTime);
-        // Store extracted patterns in AgentDB
-        let patternsStored = 0;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            await bridge.bridgeStoreEntry({
-                key: `pretrain-${Date.now()}`,
-                value: JSON.stringify({ filesAnalyzed, totalLines, topExtensions: Object.entries(extCounts).sort((a, b) => b[1] - a[1]).slice(0, 10), importPatterns: patterns.slice(0, 20) }),
-                namespace: 'pretrain',
-                tags: ['pretrain', depth],
-            });
-            patternsStored = patterns.length;
-        }
-        catch { /* AgentDB not available */ }
-        // Feed extracted import patterns into the neural training system so
-        // pretrain actually trains, not just scans.
-        let neuralPatternsLearned = 0;
-        if (patterns.length > 0) {
-            try {
-                const intel = await import('../memory/intelligence.js');
-                await intel.initializeIntelligence({ loraLearningRate: 0.002, maxTrajectorySize: patterns.length });
-                // Record each extracted pattern as an action step
-                for (const pat of patterns.slice(0, 50)) {
-                    await intel.recordStep({ type: 'action', content: pat, metadata: { source: 'pretrain', depth } });
-                }
-                // Record the entire scan as a completed trajectory
-                const steps = patterns.slice(0, 50).map(p => ({ type: 'action', content: p }));
-                await intel.recordTrajectory(steps, 'success');
-                intel.flushPatterns();
-                neuralPatternsLearned = steps.length;
-            }
-            catch { /* intelligence not available */ }
-        }
-        return {
-            success: true,
-            _real: true,
-            path: repoPath,
-            depth,
-            durationMs: elapsed,
-            stats: {
-                filesAnalyzed,
-                totalLines,
-                patternsExtracted: patterns.length,
-                patternsStored,
-                neuralPatternsLearned,
-                fileTypes: Object.entries(extCounts).sort((a, b) => b[1] - a[1]).slice(0, 15).map(([ext, count]) => ({ ext, count })),
-            },
-        };
-    },
-};
-// 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 (v1-implementation, security, performance, all)' },
-            format: { type: 'string', description: 'Config format (yaml, json)' },
-            persist: { type: 'boolean', description: 'Write configs to disk' },
-        },
-    },
-    handler: async (params) => {
-        const rawOutputDir = resolve(params.outputDir || './agents');
-        const outputDir = rawOutputDir;
-        if (!outputDir.startsWith(getProjectCwd() + sep) && outputDir !== getProjectCwd()) {
-            return { error: 'Invalid outputDir: must be within the project directory.' };
-        }
-        const focus = params.focus || 'all';
-        // Strict allowlist on `format` — without this, `format = "yaml/../../../etc/cron.d/x"`
-        // collapses through `join` and lets writes escape the validated outputDir.
-        const ALLOWED_FORMATS = new Set(['yaml', 'json']);
-        const formatRaw = params.format || 'yaml';
-        if (!ALLOWED_FORMATS.has(formatRaw)) {
-            return { error: 'Invalid format: must be yaml or json' };
-        }
-        const format = formatRaw;
-        const persist = params.persist !== false; // Default to true
-        const agents = [
-            { type: 'coder', configFile: join(outputDir, `coder.${format}`), capabilities: ['code-generation', 'refactoring', 'debugging'], optimizations: ['token-reduction', 'context-caching'] },
-            { 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`;
-                const _cftmp = agent.configFile + '.tmp';
-                writeFileSync(_cftmp, content, 'utf-8');
-                renameSync(_cftmp, agent.configFile);
-            }
-        }
-        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;
-        // Validate sourcePath is an existing directory before reading from it
-        const resolvedSource = resolve(sourcePath);
-        const { statSync } = await import('fs');
-        const { homedir } = await import('os');
-        const home = homedir();
-        if (resolvedSource !== home && !resolvedSource.startsWith(home + sep)) {
-            return { error: 'sourcePath must be within the home directory.' };
-        }
-        try {
-            const st = statSync(resolvedSource);
-            if (!st.isDirectory()) {
-                return { error: 'sourcePath must be a directory' };
-            }
-        }
-        catch {
-            return { error: 'sourcePath does not exist' };
-        }
-        // Try to load patterns from source project's memory store
-        const sourceMemoryPath = join(resolvedSource, MEMORY_DIR, MEMORY_FILE);
-        let sourceStore = { entries: {}, version: '3.0.0' };
-        const MAX_SOURCE_STORE_BYTES = 50 * 1024 * 1024; // 50 MB — matches other store readers
-        try {
-            if (existsSync(sourceMemoryPath) && statSync(sourceMemoryPath).size <= MAX_SOURCE_STORE_BYTES) {
-                sourceStore = JSON.parse(readFileSync(sourceMemoryPath, 'utf-8'));
-            }
-        }
-        catch {
-            // Fall back to empty store
-        }
-        const sourceEntries = Object.values(sourceStore.entries);
-        // Count patterns by type from source
-        const byType = {
-            'file-patterns': sourceEntries.filter(e => e.key.includes('file') || e.metadata?.type === 'file-pattern').length,
-            'task-routing': sourceEntries.filter(e => e.key.includes('routing') || e.metadata?.type === 'routing').length,
-            'command-risk': sourceEntries.filter(e => e.key.includes('command') || e.metadata?.type === 'command-risk').length,
-            'agent-success': sourceEntries.filter(e => e.key.includes('agent') || e.metadata?.type === 'agent-success').length,
-        };
-        // If source has no patterns, report honestly instead of substituting demo data
-        if (Object.values(byType).every(v => v === 0)) {
-            return {
-                success: false,
-                message: 'No patterns found in source project',
-                sourcePath,
-                transferred: 0,
-            };
-        }
-        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 {
-            success: true,
-            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',
-            },
-            dataSource: 'source-project',
-        };
-    },
-};
-// 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: 'Start worker daemon (default: false — opt-in to prevent unintended token usage)' },
-        },
-    },
-    handler: async (params) => {
-        const sessionId = params.sessionId || `session-${Date.now()}`;
-        const restoreLatest = params.restoreLatest;
-        const shouldStartDaemon = params.startDaemon === true;
-        // 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(getProjectCwd());
-                const status = daemon.getStatus();
-                daemonStatus = {
-                    started: true,
-                    pid: status.pid,
-                };
-            }
-            catch (error) {
-                daemonStatus = {
-                    started: false,
-                    error: error instanceof Error ? error.message : String(error),
-                };
-            }
-        }
-        // Phase 5: Wire ReflexionMemory session start via bridge
-        let sessionMemory = null;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            const result = await bridge.bridgeSessionStart({
-                sessionId,
-                context: restoreLatest ? 'restore previous session patterns' : 'new session',
-            });
-            if (result) {
-                sessionMemory = {
-                    controller: result.controller,
-                    restoredPatterns: result.restoredPatterns,
-                };
-            }
-        }
-        catch {
-            // Bridge not available
-        }
-        return {
-            sessionId,
-            started: new Date().toISOString(),
-            restored: restoreLatest,
-            config: {
-                intelligenceEnabled: true,
-                hooksEnabled: true,
-                memoryPersistence: true,
-                daemonEnabled: shouldStartDaemon,
-            },
-            daemon: daemonStatus,
-            sessionMemory: sessionMemory || { controller: 'none', restoredPatterns: 0 },
-            previousSession: restoreLatest ? {
-                id: `session-${Date.now() - 86400000}`,
-                tasksRestored: sessionMemory?.restoredPatterns || 3,
-                memoryRestored: sessionMemory?.restoredPatterns || 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;
-        // Use caller-supplied sessionId if provided, otherwise generate a current-time ID.
-        // The -3600000 offset was incorrect — it prevented matching session-start IDs.
-        const sessionId = typeof params.sessionId === 'string' && params.sessionId
-            ? params.sessionId
-            : `session-${Date.now()}`;
-        // 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
-            }
-        }
-        // Read actual counts from stores
-        const store = loadMemoryStore();
-        const allEntries = Object.values(store.entries);
-        const taskCount = allEntries.filter(e => e.key.includes('task')).length;
-        const agentCount = allEntries.filter(e => e.key.includes('agent')).length;
-        const patternCount = allEntries.filter(e => e.key.includes('pattern')).length;
-        const trajectoryCount = activeTrajectories.size;
-        // Check for pending-insights.jsonl
-        let insightCount = 0;
-        try {
-            const insightsPath = join(getProjectCwd(), '.monomind', 'data', 'pending-insights.jsonl');
-            if (existsSync(insightsPath)) {
-                const content = readFileSync(insightsPath, 'utf-8').trim();
-                insightCount = content ? content.split('\n').length : 0;
-            }
-        }
-        catch {
-            // File not available
-        }
-        // Phase 5: Wire ReflexionMemory session end + NightlyLearner consolidation via bridge
-        let sessionPersistence = null;
-        try {
-            const bridge = await import('../memory/memory-bridge.js');
-            const result = await bridge.bridgeSessionEnd({
-                sessionId,
-                summary: saveState ? 'Session ended with state saved' : 'Session ended',
-                tasksCompleted: taskCount,
-                patternsLearned: patternCount,
-            });
-            if (result) {
-                sessionPersistence = {
-                    controller: result.controller,
-                    persisted: result.persisted,
-                };
-            }
-        }
-        catch {
-            // Bridge not available
-        }
-        return {
-            sessionId,
-            duration: 3600000, // 1 hour in ms
-            statePath: saveState ? `.claude/sessions/${sessionId}.json` : undefined,
-            daemon: { stopped: daemonStopped },
-            sessionPersistence: sessionPersistence || { controller: 'none', persisted: false },
-            summary: {
-                tasksExecuted: taskCount,
-                filesModified: 0,
-                agentsSpawned: agentCount,
-                pendingInsights: insightCount,
-                memoryEntries: allEntries.length,
-            },
-            learningUpdates: {
-                patternsLearned: patternCount,
-                trajectoriesRecorded: trajectoryCount,
-            },
-        };
-    },
-};
-// 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()}`;
-        // Get real memory entry count
-        const store = loadMemoryStore();
-        const memoryEntryCount = Object.keys(store.entries).length;
-        // Count task and agent entries
-        const taskEntries = Object.keys(store.entries).filter(k => k.includes('task')).length;
-        const agentEntries = Object.keys(store.entries).filter(k => k.includes('agent')).length;
-        return {
-            sessionId: newSessionId,
-            originalSessionId,
-            restoredState: {
-                tasksRestored: restoreTasks ? Math.min(taskEntries, 10) : 0,
-                agentsRestored: restoreAgents ? Math.min(agentEntries, 5) : 0,
-                memoryRestored: memoryEntryCount,
-            },
-            warnings: restoreTasks && taskEntries > 0 ? [`${Math.min(taskEntries, 2)} tasks were in progress and may need review`] : undefined,
-            dataSource: 'memory-store',
-        };
-    },
-};
-// 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 - JS pattern/trajectory logging
-export const hooksIntelligence = {
-    name: 'hooks_intelligence',
-    description: 'Intelligence status: pattern/trajectory logging metrics from the memory store',
-    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;
-        // Get REAL statistics from memory store
-        const realStats = getIntelligenceStatsFromMemory();
-        // Check actual implementation availability
-        const sonaAvailable = (await getSONAOptimizer()) !== null;
-        return {
-            mode,
-            status: 'active',
-            components: {
-                sona: {
-                    enabled: enableSona,
-                    status: sonaAvailable ? 'active' : 'idle',
-                    implemented: true,
-                    trajectoriesRecorded: realStats.trajectories.total,
-                    trajectoriesSuccessful: realStats.trajectories.successful,
-                    patternsLearned: realStats.patterns.learned,
-                    note: 'Trajectory + pattern logging (no neural training in the lean build)',
-                },
-                moe: {
-                    enabled: false,
-                    status: 'removed',
-                    implemented: false,
-                    routingDecisions: realStats.routing.decisions,
-                    note: 'MoE removed in lean build; keyword routing is used instead (see monoes-full-loop)',
-                },
-                hnsw: {
-                    enabled: enableHnsw,
-                    status: enableHnsw ? 'active' : 'disabled',
-                    implemented: true,
-                    indexSize: realStats.memory.indexSize,
-                    memorySizeBytes: realStats.memory.memorySizeBytes,
-                    note: 'Pure-JS HNSW vector indexing (O(log n) vs O(n))',
-                },
-                flashAttention: {
-                    enabled: false,
-                    status: 'removed',
-                    implemented: false,
-                    note: 'Flash Attention removed in lean build; lives on monoes-full-loop branch',
-                },
-                ewc: {
-                    enabled: false,
-                    status: 'removed',
-                    implemented: false,
-                    note: 'EWC++ removed in lean build; lives on monoes-full-loop branch',
-                },
-                lora: {
-                    enabled: false,
-                    status: 'removed',
-                    implemented: false,
-                    note: 'LoRA removed in lean build; lives on monoes-full-loop branch',
-                },
-                embeddings: {
-                    provider: 'transformers',
-                    model: 'Xenova/all-MiniLM-L6-v2',
-                    dimension: 384,
-                    implemented: true,
-                    note: 'Real ONNX embeddings via Xenova/all-MiniLM-L6-v2',
-                },
-            },
-            realMetrics: {
-                trajectories: realStats.trajectories,
-                patterns: realStats.patterns,
-                memory: realStats.memory,
-                routing: realStats.routing,
-            },
-            implementationStatus: {
-                working: [
-                    'memory-store', 'embeddings', 'trajectory-recording', 'claims', 'swarm-coordination',
-                    'hnsw-index', 'pattern-storage', 'keyword-routing'
-                ],
-                partial: [],
-                notImplemented: [],
-                removed: [
-                    'moe-routing', 'flash-attention', 'lora-adapter',
-                    'native-sona-engine', 'native-router', 'native-attention',
-                ],
-            },
-            version: '3.0.0-alpha.102',
-        };
-    },
-};
-// 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);
-        }
-        // 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 {
-                    // SONA learning failed, continue without it
-                }
-            }
-            // 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 {
-                        // EWC consolidation failed, continue without it
-                    }
-                }
-            }
-        }
-        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, type, confidence, metadata: metadata });
-        }
-        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?.controller || (storeResult.success ? 'bridge-store' : 'none');
-        return {
-            patternId: reasoningResult?.patternId || storeResult.id || patternId,
-            pattern,
-            type,
-            confidence,
-            indexed: success,
-            hnswIndexed: success && (!!storeResult.embedding || controller === 'reasoningBank'),
-            embedding: storeResult.embedding,
-            timestamp,
-            controller,
-            implementation: controller === 'reasoningBank' ? 'reasoning-bank-controller' : (storeResult.success ? 'real-hnsw-indexed' : 'memory-only'),
-            note: controller === 'reasoningBank'
-                ? 'Pattern stored via ReasoningBank controller 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, topK, minConfidence });
-            if (rbResult && rbResult.results.length > 0) {
-                return {
-                    query,
-                    results: rbResult.results.map(r => ({
-                        patternId: r.id,
-                        pattern: r.content,
-                        similarity: r.score,
-                        confidence: r.score,
-                        namespace,
-                    })),
-                    searchTimeMs: 0,
-                    backend: rbResult.controller,
-                    note: `Results from ${rbResult.controller} controller`,
-                };
-            }
-        }
-        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: 'Force immediate SONA learning cycle with EWC++ consolidation',
-    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,
-                _stub: implementation === 'none',
-                _note: implementation === 'none' ? 'Pure-JS similarity only; native attention backends are not part of the lean build.' : undefined,
-            },
-            implementation,
-        };
-    },
-};
-/**
- * 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;
-    },
-};
-// 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));
-}
-// 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(),
-        };
-    },
-};
+import { hooksPreEdit, hooksPostEdit, hooksPreCommand, hooksPostCommand, hooksRoute, hooksMetrics, hooksList, hooksPreTask, hooksPostTask, hooksExplain, hooksPretrain, hooksBuildAgents, hooksTransfer, hooksSessionStart, hooksSessionEnd, hooksSessionRestore, hooksNotify, hooksInit, hooksIntelligence, } from './hooks-routing.js';
+import { hooksIntelligenceReset, hooksTrajectoryStart, hooksTrajectoryStep, hooksTrajectoryEnd, hooksPatternStore, hooksPatternSearch, hooksIntelligenceStats, hooksIntelligenceLearn, hooksIntelligenceAttention, hooksWorkerList, hooksWorkerDispatch, hooksWorkerStatus, hooksWorkerDetect, hooksWorkerCancel, hooksModelRoute, hooksModelOutcome, hooksModelStats, } from './hooks-intelligence.js';
 // Export all hooks tools
 export const hooksTools = [
     hooksPreEdit,