#!/usr/bin/env node

/**
 * RuVector MCP Server
 *
 * Model Context Protocol server for RuVector hooks
 * Provides self-learning intelligence tools for Claude Code
 *
 * Usage:
 *   npx ruvector mcp start
 *   claude mcp add ruvector npx ruvector mcp start
 */

// Signal that this is an MCP server (enables parallel workers for embeddings)
process.env.MCP_SERVER = '1';

const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} = require('@modelcontextprotocol/sdk/types.js');
const path = require('path');
const fs = require('fs');
const { execSync, execFileSync } = require('child_process');

// ── Security Helpers ────────────────────────────────────────────────────────

/**
 * Validate a file path argument for RVF operations.
 * Prevents path traversal and restricts to safe locations.
 */
function validateRvfPath(filePath) {
  if (typeof filePath !== 'string' || filePath.length === 0) {
    throw new Error('Path must be a non-empty string');
  }
  // Block null bytes
  if (filePath.includes('\0')) {
    throw new Error('Path contains null bytes');
  }
  // Resolve to absolute, then canonicalize via realpath if it exists
  let resolved = path.resolve(filePath);
  try {
    // Resolve symlinks for existing paths to prevent symlink-based escapes
    resolved = fs.realpathSync(resolved);
  } catch {
    // Path doesn't exist yet — resolve the parent directory
    const parentDir = path.dirname(resolved);
    try {
      const realParent = fs.realpathSync(parentDir);
      resolved = path.join(realParent, path.basename(resolved));
    } catch {
      // Parent doesn't exist either — keep the resolved path for the block check
    }
  }
  // Confine to the current working directory
  const cwd = process.cwd();
  if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
    // Also block sensitive system paths regardless
    const blocked = ['/etc', '/proc', '/sys', '/dev', '/boot', '/root', '/var/run', '/var/log', '/tmp'];
    for (const prefix of blocked) {
      if (resolved.startsWith(prefix)) {
        throw new Error(`Access denied: path resolves to '${resolved}' which is outside the working directory and in restricted area '${prefix}'`);
      }
    }
    // Allow paths outside cwd only if they're not in blocked directories
    // (for tools that reference project files by absolute path)
  }
  return resolved;
}

/**
 * Sanitize a shell argument to prevent command injection.
 * Strips shell metacharacters and limits length.
 */
function sanitizeShellArg(arg) {
  if (typeof arg !== 'string') return '';
  // Remove null bytes, backticks, $(), quotes, newlines, and other shell metacharacters
  return arg
    .replace(/\0/g, '')
    .replace(/[\r\n]/g, '')
    .replace(/[`$(){}|;&<>!'"\\]/g, '')
    .replace(/\.\./g, '')
    .slice(0, 4096);
}

/**
 * Validate a numeric argument (returns integer or default).
 * Prevents injection via numeric-looking fields.
 */
function sanitizeNumericArg(arg, defaultVal) {
  const n = parseInt(arg, 10);
  return Number.isFinite(n) && n > 0 ? n : (defaultVal || 0);
}

// Try to load the full IntelligenceEngine
let IntelligenceEngine = null;
let engineAvailable = false;

try {
  const core = require('../dist/core/intelligence-engine.js');
  IntelligenceEngine = core.IntelligenceEngine || core.default;
  engineAvailable = true;
} catch (e) {
  // IntelligenceEngine not available
}

// Intelligence class with full RuVector stack support
class Intelligence {
  constructor() {
    this.intelPath = this.getIntelPath();
    this.data = this.load();
    this.engine = null;

    // Initialize full engine if available
    if (engineAvailable && IntelligenceEngine) {
      try {
        this.engine = new IntelligenceEngine({
          embeddingDim: 256,
          maxMemories: 100000,
          enableSona: true,
          enableAttention: true,
        });
        // Import existing data
        if (this.data) {
          this.engine.import(this.convertLegacyData(this.data), true);
        }
      } catch (e) {
        this.engine = null;
      }
    }
  }

  convertLegacyData(data) {
    const converted = { memories: [], routingPatterns: {}, errorPatterns: {}, coEditPatterns: {} };
    if (data.memories) {
      converted.memories = data.memories.map(m => ({
        id: m.id || `mem-${Date.now()}`,
        content: m.content,
        type: m.type || 'general',
        embedding: m.embedding || [],
        created: m.created || new Date().toISOString(),
        accessed: 0,
      }));
    }
    if (data.patterns) {
      for (const [key, value] of Object.entries(data.patterns)) {
        const [state, action] = key.split('|');
        if (state && action) {
          if (!converted.routingPatterns[state]) converted.routingPatterns[state] = {};
          converted.routingPatterns[state][action] = value.q_value || value || 0.5;
        }
      }
    }
    return converted;
  }

  getIntelPath() {
    const projectPath = path.join(process.cwd(), '.ruvector', 'intelligence.json');
    const homePath = path.join(require('os').homedir(), '.ruvector', 'intelligence.json');
    if (fs.existsSync(path.dirname(projectPath))) return projectPath;
    if (fs.existsSync(path.join(process.cwd(), '.claude'))) return projectPath;
    if (fs.existsSync(homePath)) return homePath;
    return projectPath;
  }

  load() {
    try {
      if (fs.existsSync(this.intelPath)) {
        return JSON.parse(fs.readFileSync(this.intelPath, 'utf-8'));
      }
    } catch {}
    return { patterns: {}, memories: [], trajectories: [], errors: {}, agents: {}, edges: [] };
  }

  save() {
    const dir = path.dirname(this.intelPath);
    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });

    // Export engine data if available
    if (this.engine) {
      try {
        const engineData = this.engine.export();
        this.data.engineStats = engineData.stats;
      } catch {}
    }

    fs.writeFileSync(this.intelPath, JSON.stringify(this.data, null, 2));
  }

  stats() {
    const baseStats = {
      total_patterns: Object.keys(this.data.patterns || {}).length,
      total_memories: (this.data.memories || []).length,
      total_trajectories: (this.data.trajectories || []).length,
      total_errors: Object.keys(this.data.errors || {}).length
    };

    if (this.engine) {
      try {
        const engineStats = this.engine.getStats();
        return {
          ...baseStats,
          engineEnabled: true,
          sonaEnabled: engineStats.sonaEnabled,
          attentionEnabled: engineStats.attentionEnabled,
          embeddingDim: engineStats.memoryDimensions,
          totalMemories: engineStats.totalMemories,
          totalEpisodes: engineStats.totalEpisodes,
          trajectoriesRecorded: engineStats.trajectoriesRecorded,
          patternsLearned: engineStats.patternsLearned,
          microLoraUpdates: engineStats.microLoraUpdates,
          ewcConsolidations: engineStats.ewcConsolidations,
        };
      } catch {}
    }

    return { ...baseStats, engineEnabled: false };
  }

  embed(text) {
    if (this.engine) {
      try {
        return this.engine.embed(text);
      } catch {}
    }
    // Fallback: 64-dim hash
    const embedding = new Array(64).fill(0);
    for (let i = 0; i < text.length; i++) {
      const idx = (text.charCodeAt(i) + i * 7) % 64;
      embedding[idx] += 1.0;
    }
    const norm = Math.sqrt(embedding.reduce((a, b) => a + b * b, 0));
    if (norm > 0) for (let i = 0; i < embedding.length; i++) embedding[i] /= norm;
    return embedding;
  }

  similarity(a, b) {
    if (!a || !b || a.length !== b.length) return 0;
    const dot = a.reduce((sum, v, i) => sum + v * b[i], 0);
    const normA = Math.sqrt(a.reduce((sum, v) => sum + v * v, 0));
    const normB = Math.sqrt(b.reduce((sum, v) => sum + v * v, 0));
    return normA > 0 && normB > 0 ? dot / (normA * normB) : 0;
  }

  async remember(content, type = 'general') {
    // Use engine if available (VectorDB storage)
    if (this.engine) {
      try {
        const entry = await this.engine.remember(content, type);
        // Also store in legacy format
        this.data.memories = this.data.memories || [];
        this.data.memories.push({ content, type, created: new Date().toISOString(), embedding: entry.embedding });
        this.save();
        return { stored: true, total: this.data.memories.length, engineStored: true };
      } catch {}
    }

    // Fallback
    this.data.memories = this.data.memories || [];
    this.data.memories.push({ content, type, created: new Date().toISOString(), embedding: this.embed(content) });
    this.save();
    return { stored: true, total: this.data.memories.length };
  }

  async recall(query, topK = 5) {
    // Use engine if available (HNSW search - 150x faster)
    if (this.engine) {
      try {
        const results = await this.engine.recall(query, topK);
        return results.map(r => ({
          content: r.content,
          type: r.type,
          score: r.score || 0,
          created: r.created,
          engineResult: true
        }));
      } catch {}
    }

    // Fallback: brute-force
    const queryEmbed = this.embed(query);
    const scored = (this.data.memories || []).map((m, i) => ({
      ...m,
      index: i,
      score: this.similarity(queryEmbed, m.embedding)
    }));
    return scored.sort((a, b) => b.score - a.score).slice(0, topK);
  }

  async route(task, file = null) {
    // Use engine if available (SONA-enhanced routing)
    if (this.engine) {
      try {
        const result = await this.engine.route(task, file);
        return {
          agent: result.agent,
          confidence: result.confidence,
          reason: result.reason,
          alternates: result.alternates,
          sonaPatterns: result.patterns?.length || 0,
          engineRouted: true
        };
      } catch {}
    }

    // Fallback
    const ext = file ? path.extname(file) : '';
    const state = `edit:${ext || 'unknown'}`;
    const actions = this.data.patterns[state] || {};

    const defaults = {
      '.rs': 'rust-developer',
      '.ts': 'typescript-developer',
      '.tsx': 'react-developer',
      '.js': 'javascript-developer',
      '.jsx': 'react-developer',
      '.py': 'python-developer',
      '.go': 'go-developer',
      '.sql': 'database-specialist',
      '.md': 'documentation-specialist'
    };

    let bestAgent = defaults[ext] || 'coder';
    let bestScore = 0.5;

    for (const [agent, score] of Object.entries(actions)) {
      if (score > bestScore) {
        bestAgent = agent;
        bestScore = score;
      }
    }

    return {
      agent: bestAgent,
      confidence: Math.min(bestScore, 1.0),
      reason: Object.keys(actions).length > 0 ? 'learned from patterns' : 'default mapping'
    };
  }

  getCapabilities() {
    if (!this.engine) {
      return { engine: false, vectorDb: false, sona: false, attention: false, embeddingDim: 64 };
    }
    try {
      const stats = this.engine.getStats();
      return {
        engine: true,
        vectorDb: true,
        sona: stats.sonaEnabled,
        attention: stats.attentionEnabled,
        embeddingDim: stats.memoryDimensions,
      };
    } catch {
      return { engine: true, vectorDb: false, sona: false, attention: false, embeddingDim: 256 };
    }
  }
}

// Create MCP server
const server = new Server(
  {
    name: 'ruvector',
    version: '0.1.58',
  },
  {
    capabilities: {
      tools: {},
      resources: {},
    },
  }
);

const intel = new Intelligence();

// Define tools
const TOOLS = [
  {
    name: 'hooks_stats',
    description: 'Get RuVector intelligence statistics including learned patterns, memories, and trajectories',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_route',
    description: 'Route a task to the best agent based on learned patterns',
    inputSchema: {
      type: 'object',
      properties: {
        task: { type: 'string', description: 'Task description' },
        file: { type: 'string', description: 'File path (optional)' }
      },
      required: ['task']
    }
  },
  {
    name: 'hooks_remember',
    description: 'Store context in vector memory for later recall',
    inputSchema: {
      type: 'object',
      properties: {
        content: { type: 'string', description: 'Content to remember' },
        type: { type: 'string', description: 'Memory type (project, code, decision, context)', default: 'general' }
      },
      required: ['content']
    }
  },
  {
    name: 'hooks_recall',
    description: 'Search vector memory for relevant context',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Search query' },
        top_k: { type: 'number', description: 'Number of results', default: 5 }
      },
      required: ['query']
    }
  },
  {
    name: 'hooks_init',
    description: 'Initialize RuVector hooks in the current project',
    inputSchema: {
      type: 'object',
      properties: {
        pretrain: { type: 'boolean', description: 'Run pretrain after init', default: false },
        build_agents: { type: 'string', description: 'Focus for agent generation (quality, speed, security, testing, fullstack)' },
        force: { type: 'boolean', description: 'Force overwrite existing settings', default: false }
      },
      required: []
    }
  },
  {
    name: 'hooks_pretrain',
    description: 'Pretrain intelligence by analyzing the repository structure and git history',
    inputSchema: {
      type: 'object',
      properties: {
        depth: { type: 'number', description: 'Git history depth to analyze', default: 100 },
        skip_git: { type: 'boolean', description: 'Skip git history analysis', default: false },
        verbose: { type: 'boolean', description: 'Show detailed progress', default: false }
      },
      required: []
    }
  },
  {
    name: 'hooks_build_agents',
    description: 'Generate optimized agent configurations based on repository analysis',
    inputSchema: {
      type: 'object',
      properties: {
        focus: {
          type: 'string',
          description: 'Focus type for agent generation',
          enum: ['quality', 'speed', 'security', 'testing', 'fullstack'],
          default: 'quality'
        },
        include_prompts: { type: 'boolean', description: 'Include system prompts in agent configs', default: true }
      },
      required: []
    }
  },
  {
    name: 'hooks_verify',
    description: 'Verify that hooks are configured correctly',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_doctor',
    description: 'Diagnose and optionally fix setup issues',
    inputSchema: {
      type: 'object',
      properties: {
        fix: { type: 'boolean', description: 'Automatically fix issues', default: false }
      },
      required: []
    }
  },
  {
    name: 'hooks_export',
    description: 'Export intelligence data for backup',
    inputSchema: {
      type: 'object',
      properties: {
        include_all: { type: 'boolean', description: 'Include all data (patterns, memories, trajectories)', default: false }
      },
      required: []
    }
  },
  {
    name: 'hooks_capabilities',
    description: 'Get RuVector engine capabilities (VectorDB, SONA, Attention)',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_import',
    description: 'Import intelligence data from backup file',
    inputSchema: {
      type: 'object',
      properties: {
        data: { type: 'object', description: 'Exported data object to import' },
        merge: { type: 'boolean', description: 'Merge with existing data', default: true }
      },
      required: ['data']
    }
  },
  {
    name: 'hooks_swarm_recommend',
    description: 'Get agent recommendation for a task type using learned patterns',
    inputSchema: {
      type: 'object',
      properties: {
        task_type: { type: 'string', description: 'Type of task (research, code, test, review, debug, etc.)' },
        file: { type: 'string', description: 'Optional file path for context' }
      },
      required: ['task_type']
    }
  },
  {
    name: 'hooks_suggest_context',
    description: 'Get relevant context suggestions for the current task',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Current task or query' },
        top_k: { type: 'number', description: 'Number of suggestions', default: 5 }
      },
      required: []
    }
  },
  {
    name: 'hooks_trajectory_begin',
    description: 'Begin tracking a new execution trajectory',
    inputSchema: {
      type: 'object',
      properties: {
        context: { type: 'string', description: 'Task or operation context' },
        agent: { type: 'string', description: 'Agent performing the task' }
      },
      required: ['context']
    }
  },
  {
    name: 'hooks_trajectory_step',
    description: 'Add a step to the current trajectory',
    inputSchema: {
      type: 'object',
      properties: {
        action: { type: 'string', description: 'Action taken' },
        result: { type: 'string', description: 'Result of action' },
        reward: { type: 'number', description: 'Reward signal (0-1)', default: 0.5 }
      },
      required: ['action']
    }
  },
  {
    name: 'hooks_trajectory_end',
    description: 'End the current trajectory with a quality score',
    inputSchema: {
      type: 'object',
      properties: {
        success: { type: 'boolean', description: 'Whether the task succeeded' },
        quality: { type: 'number', description: 'Quality score (0-1)', default: 0.5 }
      },
      required: []
    }
  },
  {
    name: 'hooks_coedit_record',
    description: 'Record co-edit pattern (files edited together)',
    inputSchema: {
      type: 'object',
      properties: {
        primary_file: { type: 'string', description: 'Primary file being edited' },
        related_files: { type: 'array', items: { type: 'string' }, description: 'Related files edited together' }
      },
      required: ['primary_file', 'related_files']
    }
  },
  {
    name: 'hooks_coedit_suggest',
    description: 'Get suggested related files based on co-edit patterns',
    inputSchema: {
      type: 'object',
      properties: {
        file: { type: 'string', description: 'Current file' },
        top_k: { type: 'number', description: 'Number of suggestions', default: 5 }
      },
      required: ['file']
    }
  },
  {
    name: 'hooks_error_record',
    description: 'Record an error and its fix for learning',
    inputSchema: {
      type: 'object',
      properties: {
        error: { type: 'string', description: 'Error message or code' },
        fix: { type: 'string', description: 'Fix that resolved the error' },
        file: { type: 'string', description: 'File where error occurred' }
      },
      required: ['error', 'fix']
    }
  },
  {
    name: 'hooks_error_suggest',
    description: 'Get suggested fixes for an error based on learned patterns',
    inputSchema: {
      type: 'object',
      properties: {
        error: { type: 'string', description: 'Error message or code' }
      },
      required: ['error']
    }
  },
  {
    name: 'hooks_force_learn',
    description: 'Force an immediate learning cycle',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  // ============================================
  // NEW CAPABILITY TOOLS (AST, Diff, Coverage, Graph, Security, RAG)
  // ============================================
  {
    name: 'hooks_ast_analyze',
    description: 'Parse file AST and extract symbols, imports, complexity metrics',
    inputSchema: {
      type: 'object',
      properties: {
        file: { type: 'string', description: 'File path to analyze' }
      },
      required: ['file']
    }
  },
  {
    name: 'hooks_ast_complexity',
    description: 'Get cyclomatic and cognitive complexity metrics for files',
    inputSchema: {
      type: 'object',
      properties: {
        files: { type: 'array', items: { type: 'string' }, description: 'Files to analyze' },
        threshold: { type: 'number', description: 'Warn if complexity exceeds threshold', default: 10 }
      },
      required: ['files']
    }
  },
  {
    name: 'hooks_diff_analyze',
    description: 'Analyze git diff with semantic embeddings and risk scoring',
    inputSchema: {
      type: 'object',
      properties: {
        commit: { type: 'string', description: 'Commit hash (defaults to staged changes)' }
      },
      required: []
    }
  },
  {
    name: 'hooks_diff_classify',
    description: 'Classify change type (feature, bugfix, refactor, docs, test, config)',
    inputSchema: {
      type: 'object',
      properties: {
        commit: { type: 'string', description: 'Commit hash (defaults to HEAD)' }
      },
      required: []
    }
  },
  {
    name: 'hooks_diff_similar',
    description: 'Find similar past commits based on diff embeddings',
    inputSchema: {
      type: 'object',
      properties: {
        top_k: { type: 'number', description: 'Number of results', default: 5 },
        commits: { type: 'number', description: 'Recent commits to search', default: 50 }
      },
      required: []
    }
  },
  {
    name: 'hooks_coverage_route',
    description: 'Get coverage-aware agent routing for a file',
    inputSchema: {
      type: 'object',
      properties: {
        file: { type: 'string', description: 'File to analyze' }
      },
      required: ['file']
    }
  },
  {
    name: 'hooks_coverage_suggest',
    description: 'Suggest tests for files based on coverage data',
    inputSchema: {
      type: 'object',
      properties: {
        files: { type: 'array', items: { type: 'string' }, description: 'Files to analyze' }
      },
      required: ['files']
    }
  },
  {
    name: 'hooks_graph_mincut',
    description: 'Find optimal code boundaries using MinCut algorithm (Stoer-Wagner)',
    inputSchema: {
      type: 'object',
      properties: {
        files: { type: 'array', items: { type: 'string' }, description: 'Files to analyze' }
      },
      required: ['files']
    }
  },
  {
    name: 'hooks_graph_cluster',
    description: 'Detect code communities using spectral or Louvain clustering',
    inputSchema: {
      type: 'object',
      properties: {
        files: { type: 'array', items: { type: 'string' }, description: 'Files to analyze' },
        method: { type: 'string', enum: ['spectral', 'louvain'], default: 'louvain' },
        clusters: { type: 'number', description: 'Number of clusters (spectral only)', default: 3 }
      },
      required: ['files']
    }
  },
  {
    name: 'hooks_security_scan',
    description: 'Parallel security vulnerability scan for common issues',
    inputSchema: {
      type: 'object',
      properties: {
        files: { type: 'array', items: { type: 'string' }, description: 'Files to scan' }
      },
      required: ['files']
    }
  },
  {
    name: 'hooks_rag_context',
    description: 'Get RAG-enhanced context for a query with optional reranking',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Query for context' },
        top_k: { type: 'number', description: 'Number of results', default: 5 },
        rerank: { type: 'boolean', description: 'Rerank results by relevance', default: false }
      },
      required: ['query']
    }
  },
  {
    name: 'hooks_git_churn',
    description: 'Analyze git churn to find hot spots',
    inputSchema: {
      type: 'object',
      properties: {
        days: { type: 'number', description: 'Number of days to analyze', default: 30 },
        top: { type: 'number', description: 'Top N files', default: 10 }
      },
      required: []
    }
  },
  {
    name: 'hooks_route_enhanced',
    description: 'Enhanced routing using AST complexity, coverage, and diff analysis signals',
    inputSchema: {
      type: 'object',
      properties: {
        task: { type: 'string', description: 'Task description' },
        file: { type: 'string', description: 'File context' }
      },
      required: ['task']
    }
  },
  {
    name: 'hooks_attention_info',
    description: 'Get available attention mechanisms and their configurations',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_gnn_info',
    description: 'Get GNN layer capabilities and configuration',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  // Learning Engine Tools (v2.1)
  {
    name: 'hooks_learning_config',
    description: 'Configure learning algorithms for different tasks. Supports 9 algorithms: q-learning, sarsa, double-q, actor-critic, ppo, decision-transformer, monte-carlo, td-lambda, dqn',
    inputSchema: {
      type: 'object',
      properties: {
        task: {
          type: 'string',
          description: 'Task type: agent-routing, error-avoidance, confidence-scoring, trajectory-learning, context-ranking, memory-recall',
          enum: ['agent-routing', 'error-avoidance', 'confidence-scoring', 'trajectory-learning', 'context-ranking', 'memory-recall']
        },
        algorithm: {
          type: 'string',
          description: 'Learning algorithm',
          enum: ['q-learning', 'sarsa', 'double-q', 'actor-critic', 'ppo', 'decision-transformer', 'monte-carlo', 'td-lambda', 'dqn']
        },
        learningRate: { type: 'number', description: 'Learning rate (0.0-1.0)' },
        discountFactor: { type: 'number', description: 'Discount factor gamma (0.0-1.0)' },
        epsilon: { type: 'number', description: 'Exploration rate (0.0-1.0)' }
      },
      required: []
    }
  },
  {
    name: 'hooks_learning_stats',
    description: 'Get learning algorithm statistics and performance metrics',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_learning_update',
    description: 'Record a learning experience for a specific task',
    inputSchema: {
      type: 'object',
      properties: {
        task: { type: 'string', description: 'Task type' },
        state: { type: 'string', description: 'Current state' },
        action: { type: 'string', description: 'Action taken' },
        reward: { type: 'number', description: 'Reward received (-1 to 1)' },
        nextState: { type: 'string', description: 'Next state (optional)' },
        done: { type: 'boolean', description: 'Episode is done' }
      },
      required: ['task', 'state', 'action', 'reward']
    }
  },
  {
    name: 'hooks_learn',
    description: 'Combined learning action: record experience and get best action recommendation',
    inputSchema: {
      type: 'object',
      properties: {
        state: { type: 'string', description: 'Current state' },
        action: { type: 'string', description: 'Action taken (optional)' },
        reward: { type: 'number', description: 'Reward (-1 to 1, optional)' },
        actions: { type: 'array', items: { type: 'string' }, description: 'Available actions for recommendation' },
        task: { type: 'string', description: 'Task type', default: 'agent-routing' }
      },
      required: ['state']
    }
  },
  {
    name: 'hooks_algorithms_list',
    description: 'List all available learning algorithms with descriptions',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  // TensorCompress Tools
  {
    name: 'hooks_compress',
    description: 'Compress pattern storage using TensorCompress. Provides up to 10x memory savings.',
    inputSchema: {
      type: 'object',
      properties: {
        force: { type: 'boolean', description: 'Force recompression of all patterns' }
      },
      required: []
    }
  },
  {
    name: 'hooks_compress_stats',
    description: 'Get TensorCompress statistics: memory savings, compression levels, tensor counts',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'hooks_compress_store',
    description: 'Store an embedding with adaptive compression',
    inputSchema: {
      type: 'object',
      properties: {
        key: { type: 'string', description: 'Storage key' },
        vector: { type: 'array', items: { type: 'number' }, description: 'Vector to store' },
        level: { type: 'string', description: 'Compression level', enum: ['none', 'half', 'pq8', 'pq4', 'binary'] }
      },
      required: ['key', 'vector']
    }
  },
  {
    name: 'hooks_compress_get',
    description: 'Retrieve a compressed embedding',
    inputSchema: {
      type: 'object',
      properties: {
        key: { type: 'string', description: 'Storage key' }
      },
      required: ['key']
    }
  },
  {
    name: 'hooks_batch_learn',
    description: 'Record multiple learning experiences in batch for efficiency. Processes an array of experiences at once.',
    inputSchema: {
      type: 'object',
      properties: {
        experiences: {
          type: 'array',
          description: 'Array of experiences to learn from',
          items: {
            type: 'object',
            properties: {
              state: { type: 'string', description: 'State identifier' },
              action: { type: 'string', description: 'Action taken' },
              reward: { type: 'number', description: 'Reward (-1 to 1)' },
              nextState: { type: 'string', description: 'Next state (optional)' },
              done: { type: 'boolean', description: 'Episode ended' }
            },
            required: ['state', 'action', 'reward']
          }
        },
        task: { type: 'string', description: 'Task type for all experiences', default: 'agent-routing' }
      },
      required: ['experiences']
    }
  },
  {
    name: 'hooks_subscribe_snapshot',
    description: 'Get current state snapshot for subscription-style updates. Returns counts and deltas since last call.',
    inputSchema: {
      type: 'object',
      properties: {
        events: {
          type: 'array',
          description: 'Event types to check',
          items: { type: 'string', enum: ['learn', 'compress', 'route', 'memory'] },
          default: ['learn', 'route']
        },
        lastState: {
          type: 'object',
          description: 'Previous state for delta calculation',
          properties: {
            patterns: { type: 'number' },
            memories: { type: 'number' },
            trajectories: { type: 'number' },
            updates: { type: 'number' }
          }
        }
      },
      required: []
    }
  },
  {
    name: 'hooks_watch_status',
    description: 'Get file watching status and recent changes detected',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  // ============================================
  // BACKGROUND WORKERS TOOLS (via agentic-flow)
  // ============================================
  {
    name: 'workers_dispatch',
    description: 'Dispatch a background worker for analysis (ultralearn, optimize, audit, map, etc.)',
    inputSchema: {
      type: 'object',
      properties: {
        prompt: { type: 'string', description: 'Prompt with trigger keyword (e.g., "ultralearn authentication")' }
      },
      required: ['prompt']
    }
  },
  {
    name: 'workers_status',
    description: 'Get background worker status dashboard',
    inputSchema: {
      type: 'object',
      properties: {
        workerId: { type: 'string', description: 'Specific worker ID (optional)' }
      },
      required: []
    }
  },
  {
    name: 'workers_results',
    description: 'Get analysis results from completed workers',
    inputSchema: {
      type: 'object',
      properties: {
        json: { type: 'boolean', description: 'Return as JSON', default: false }
      },
      required: []
    }
  },
  {
    name: 'workers_triggers',
    description: 'List available trigger keywords for workers',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'workers_stats',
    description: 'Get worker statistics (24h)',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  // Custom Worker System (agentic-flow@alpha.39+)
  {
    name: 'workers_presets',
    description: 'List available worker presets (quick-scan, deep-analysis, security-scan, learning, api-docs, test-analysis)',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'workers_phases',
    description: 'List available phase executors (24 phases including file-discovery, security-analysis, pattern-extraction)',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'workers_create',
    description: 'Create a custom worker from preset with composable phases',
    inputSchema: {
      type: 'object',
      properties: {
        name: { type: 'string', description: 'Worker name' },
        preset: { type: 'string', description: 'Base preset (quick-scan, deep-analysis, security-scan, learning, api-docs, test-analysis)' },
        triggers: { type: 'string', description: 'Comma-separated trigger keywords' }
      },
      required: ['name']
    }
  },
  {
    name: 'workers_run',
    description: 'Run a custom worker on target path',
    inputSchema: {
      type: 'object',
      properties: {
        name: { type: 'string', description: 'Worker name' },
        path: { type: 'string', description: 'Target path to analyze (default: .)' }
      },
      required: ['name']
    }
  },
  {
    name: 'workers_custom',
    description: 'List registered custom workers',
    inputSchema: {
      type: 'object',
      properties: {},
      required: []
    }
  },
  {
    name: 'workers_init_config',
    description: 'Generate example workers.yaml config file',
    inputSchema: {
      type: 'object',
      properties: {
        force: { type: 'boolean', description: 'Overwrite existing config' }
      },
      required: []
    }
  },
  {
    name: 'workers_load_config',
    description: 'Load custom workers from workers.yaml config file',
    inputSchema: {
      type: 'object',
      properties: {
        file: { type: 'string', description: 'Config file path (default: workers.yaml)' }
      },
      required: []
    }
  },
  // ── RVF Vector Store Tools ────────────────────────────────────────────────
  {
    name: 'rvf_create',
    description: 'Create a new RVF vector store (.rvf file) with specified dimensions and distance metric',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'File path for the new .rvf store' },
        dimension: { type: 'number', description: 'Vector dimensionality (e.g. 128, 384, 768, 1536)' },
        metric: { type: 'string', description: 'Distance metric: cosine, l2, or dotproduct', default: 'cosine' }
      },
      required: ['path', 'dimension']
    }
  },
  {
    name: 'rvf_open',
    description: 'Open an existing RVF store for read-write operations',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to existing .rvf file' }
      },
      required: ['path']
    }
  },
  {
    name: 'rvf_ingest',
    description: 'Insert vectors into an RVF store',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' },
        entries: { type: 'array', description: 'Array of {id, vector, metadata?} objects', items: { type: 'object' } }
      },
      required: ['path', 'entries']
    }
  },
  {
    name: 'rvf_query',
    description: 'Query nearest neighbors in an RVF store',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' },
        vector: { type: 'array', description: 'Query vector as array of numbers', items: { type: 'number' } },
        k: { type: 'number', description: 'Number of results to return', default: 10 }
      },
      required: ['path', 'vector']
    }
  },
  {
    name: 'rvf_delete',
    description: 'Delete vectors by ID from an RVF store',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' },
        ids: { type: 'array', description: 'Vector IDs to delete', items: { type: 'number' } }
      },
      required: ['path', 'ids']
    }
  },
  {
    name: 'rvf_status',
    description: 'Get status of an RVF store (vector count, dimension, metric, file size)',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' }
      },
      required: ['path']
    }
  },
  {
    name: 'rvf_compact',
    description: 'Compact an RVF store to reclaim space from deleted vectors',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' }
      },
      required: ['path']
    }
  },
  {
    name: 'rvf_derive',
    description: 'Derive a child RVF store from a parent using copy-on-write branching',
    inputSchema: {
      type: 'object',
      properties: {
        parent_path: { type: 'string', description: 'Path to parent .rvf store' },
        child_path: { type: 'string', description: 'Path for the new child .rvf store' }
      },
      required: ['parent_path', 'child_path']
    }
  },
  {
    name: 'rvf_segments',
    description: 'List all segments in an RVF file (VEC, INDEX, KERNEL, EBPF, WITNESS, etc.)',
    inputSchema: {
      type: 'object',
      properties: {
        path: { type: 'string', description: 'Path to .rvf store' }
      },
      required: ['path']
    }
  },
  {
    name: 'rvf_examples',
    description: 'List available example .rvf files with download URLs from the ruvector repository',
    inputSchema: {
      type: 'object',
      properties: {
        filter: { type: 'string', description: 'Filter examples by name or description substring' }
      },
      required: []
    }
  },
  // ── rvlite Query Tools ──────────────────────────────────────────────────
  {
    name: 'rvlite_sql',
    description: 'Execute SQL query over rvlite vector database with optional RVF backend',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'SQL query string (supports distance() and vec_search() functions)' },
        db_path: { type: 'string', description: 'Path to database file (optional)' }
      },
      required: ['query']
    }
  },
  {
    name: 'rvlite_cypher',
    description: 'Execute Cypher graph query over rvlite property graph',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Cypher query string' },
        db_path: { type: 'string', description: 'Path to database file (optional)' }
      },
      required: ['query']
    }
  },
  {
    name: 'rvlite_sparql',
    description: 'Execute SPARQL query over rvlite RDF triple store',
    inputSchema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'SPARQL query string' },
        db_path: { type: 'string', description: 'Path to database file (optional)' }
      },
      required: ['query']
    }
  }
];

// List tools handler
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return { tools: TOOLS };
});

// Call tool handler
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  try {
    switch (name) {
      case 'hooks_stats': {
        const stats = intel.stats();
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              stats,
              intel_path: intel.intelPath
            }, null, 2)
          }]
        };
      }

      case 'hooks_route': {
        const result = await intel.route(args.task, args.file);
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              task: args.task,
              file: args.file,
              ...result
            }, null, 2)
          }]
        };
      }

      case 'hooks_remember': {
        const result = await intel.remember(args.content, args.type || 'general');
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              ...result
            }, null, 2)
          }]
        };
      }

      case 'hooks_recall': {
        const results = await intel.recall(args.query, args.top_k || 5);
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              query: args.query,
              results: results.map(r => ({
                content: r.content,
                type: r.type,
                score: typeof r.score === 'number' ? r.score.toFixed(3) : r.score,
                created: r.created,
                engineResult: r.engineResult || false
              }))
            }, null, 2)
          }]
        };
      }

      case 'hooks_init': {
        let cmd = 'npx ruvector hooks init';
        if (args.force) cmd += ' --force';
        if (args.pretrain) cmd += ' --pretrain';
        if (args.build_agents) cmd += ` --build-agents ${sanitizeShellArg(args.build_agents)}`;

        try {
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 60000 });
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: true, output }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message }, null, 2)
            }]
          };
        }
      }

      case 'hooks_pretrain': {
        let cmd = 'npx ruvector hooks pretrain';
        if (args.depth) cmd += ` --depth ${sanitizeNumericArg(args.depth, 3)}`;
        if (args.skip_git) cmd += ' --skip-git';
        if (args.verbose) cmd += ' --verbose';

        try {
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 120000 });
          // Reload intelligence after pretrain
          intel.data = intel.load();
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({
                success: true,
                output,
                new_stats: intel.stats()
              }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message }, null, 2)
            }]
          };
        }
      }

      case 'hooks_build_agents': {
        let cmd = 'npx ruvector hooks build-agents';
        if (args.focus) cmd += ` --focus ${sanitizeShellArg(args.focus)}`;
        if (args.include_prompts) cmd += ' --include-prompts';

        try {
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: true, output }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message }, null, 2)
            }]
          };
        }
      }

      case 'hooks_verify': {
        try {
          const output = execSync('npx ruvector hooks verify', { encoding: 'utf-8', timeout: 15000 });
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: true, output }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message, output: e.stdout }, null, 2)
            }]
          };
        }
      }

      case 'hooks_doctor': {
        let cmd = 'npx ruvector hooks doctor';
        if (args.fix) cmd += ' --fix';

        try {
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 15000 });
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: true, output }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message }, null, 2)
            }]
          };
        }
      }

      case 'hooks_export': {
        const exportData = {
          version: '2.0',
          exported_at: new Date().toISOString(),
          patterns: intel.data.patterns || {},
          memories: args.include_all ? (intel.data.memories || []) : [],
          trajectories: args.include_all ? (intel.data.trajectories || []) : [],
          errors: intel.data.errors || {},
          stats: intel.stats(),
          capabilities: intel.getCapabilities()
        };
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, data: exportData }, null, 2)
          }]
        };
      }

      case 'hooks_capabilities': {
        const capabilities = intel.getCapabilities();
        const stats = intel.stats();
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              capabilities,
              features: {
                vectorDb: capabilities.vectorDb ? 'HNSW indexing (150x faster search)' : 'Brute-force fallback',
                sona: capabilities.sona ? 'Micro-LoRA + Base-LoRA + EWC++' : 'Q-learning fallback',
                attention: capabilities.attention ? 'Self-attention embeddings' : 'Hash embeddings',
                embeddingDim: capabilities.embeddingDim,
              },
              stats: {
                totalMemories: stats.totalMemories || stats.total_memories,
                trajectoriesRecorded: stats.trajectoriesRecorded || 0,
                patternsLearned: stats.patternsLearned || stats.total_patterns,
                microLoraUpdates: stats.microLoraUpdates || 0,
                ewcConsolidations: stats.ewcConsolidations || 0,
              }
            }, null, 2)
          }]
        };
      }

      case 'hooks_import': {
        try {
          const data = args.data;
          const merge = args.merge !== false;

          // Validate imported data structure to prevent prototype pollution and injection
          if (typeof data !== 'object' || data === null || Array.isArray(data)) {
            throw new Error('Import data must be a non-null object');
          }
          const allowedKeys = ['patterns', 'memories', 'errors', 'agents', 'edges', 'trajectories'];
          for (const key of Object.keys(data)) {
            if (!allowedKeys.includes(key)) {
              throw new Error(`Unknown import key: '${key}'. Allowed: ${allowedKeys.join(', ')}`);
            }
          }
          // Prevent prototype pollution via __proto__, constructor, prototype keys
          const dangerousKeys = ['__proto__', 'constructor', 'prototype'];
          function checkForProtoPollution(obj, path) {
            if (typeof obj !== 'object' || obj === null) return;
            for (const key of Object.keys(obj)) {
              if (dangerousKeys.includes(key)) {
                throw new Error(`Dangerous key '${key}' detected at ${path}.${key}`);
              }
            }
          }
          if (data.patterns) checkForProtoPollution(data.patterns, 'patterns');
          if (data.errors) checkForProtoPollution(data.errors, 'errors');

          if (data.patterns && typeof data.patterns === 'object') {
            if (merge) {
              Object.assign(intel.data.patterns, data.patterns);
            } else {
              intel.data.patterns = data.patterns;
            }
          }
          if (data.memories && Array.isArray(data.memories)) {
            if (merge) {
              intel.data.memories = [...(intel.data.memories || []), ...data.memories];
            } else {
              intel.data.memories = data.memories;
            }
          }
          if (data.errors && typeof data.errors === 'object') {
            if (merge) {
              Object.assign(intel.data.errors, data.errors);
            } else {
              intel.data.errors = data.errors;
            }
          }
          intel.save();

          return {
            content: [{
              type: 'text',
              text: JSON.stringify({
                success: true,
                message: `Imported ${Object.keys(data.patterns || {}).length} patterns, ${(data.memories || []).length} memories`,
                merge
              }, null, 2)
            }]
          };
        } catch (e) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: e.message }, null, 2)
            }]
          };
        }
      }

      case 'hooks_swarm_recommend': {
        const taskType = args.task_type || '';
        const file = args.file || '';

        // Map task types to recommended agents
        const taskAgentMap = {
          research: ['researcher', 'analyst', 'explorer'],
          code: ['coder', 'backend-dev', 'sparc-coder'],
          test: ['tester', 'tdd-london-swarm', 'production-validator'],
          review: ['reviewer', 'code-analyzer', 'analyst'],
          debug: ['coder', 'tester', 'analyst'],
          refactor: ['code-analyzer', 'reviewer', 'architect'],
          document: ['documenter', 'api-docs', 'researcher'],
          security: ['security-manager', 'reviewer', 'code-analyzer'],
          performance: ['perf-analyzer', 'performance-benchmarker', 'optimizer'],
          architecture: ['system-architect', 'architect', 'planner']
        };

        // Get learned route if file provided
        let learnedAgent = null;
        if (file) {
          const route = await intel.route({ task: taskType, file });
          learnedAgent = route?.agent;
        }

        const recommendations = taskAgentMap[taskType.toLowerCase()] || ['coder', 'researcher', 'analyst'];

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              task_type: taskType,
              recommendations,
              learned_agent: learnedAgent,
              suggested: learnedAgent || recommendations[0]
            }, null, 2)
          }]
        };
      }

      case 'hooks_suggest_context': {
        const query = args.query || '';
        const topK = args.top_k || 5;

        // Get relevant memories
        const memories = await intel.recall(query, topK);

        // Get recent patterns
        const recentPatterns = Object.entries(intel.data.patterns || {})
          .slice(0, topK)
          .map(([state, actions]) => ({ state, topAction: Object.keys(actions)[0] }));

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              query,
              memories: memories.map(m => ({ content: m.content, type: m.type, score: m.score })),
              patterns: recentPatterns
            }, null, 2)
          }]
        };
      }

      case 'hooks_trajectory_begin': {
        const context = args.context;
        const agent = args.agent || 'unknown';

        // Store trajectory start in intel
        if (!intel.data.activeTrajectories) intel.data.activeTrajectories = {};
        const trajId = `traj_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        intel.data.activeTrajectories[trajId] = {
          id: trajId,
          context,
          agent,
          steps: [],
          startTime: Date.now()
        };

        // Also use engine if available
        if (intel.engine) {
          try {
            intel.engine.beginTrajectory(context);
          } catch (e) { /* fallback to manual */ }
        }

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, trajectory_id: trajId, context, agent }, null, 2)
          }]
        };
      }

      case 'hooks_trajectory_step': {
        const action = args.action;
        const result = args.result || '';
        const reward = args.reward || 0.5;

        // Add to most recent trajectory
        const trajectories = intel.data.activeTrajectories || {};
        const trajIds = Object.keys(trajectories);
        if (trajIds.length === 0) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: 'No active trajectory. Call hooks_trajectory_begin first.' }, null, 2)
            }]
          };
        }

        const latestTrajId = trajIds[trajIds.length - 1];
        trajectories[latestTrajId].steps.push({ action, result, reward, time: Date.now() });

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, trajectory_id: latestTrajId, step: trajectories[latestTrajId].steps.length }, null, 2)
          }]
        };
      }

      case 'hooks_trajectory_end': {
        const success = args.success !== false;
        const quality = args.quality || (success ? 0.8 : 0.2);

        const trajectories = intel.data.activeTrajectories || {};
        const trajIds = Object.keys(trajectories);
        if (trajIds.length === 0) {
          return {
            content: [{
              type: 'text',
              text: JSON.stringify({ success: false, error: 'No active trajectory.' }, null, 2)
            }]
          };
        }

        const latestTrajId = trajIds[trajIds.length - 1];
        const traj = trajectories[latestTrajId];
        traj.endTime = Date.now();
        traj.quality = quality;
        traj.success = success;

        // Move to completed trajectories
        if (!intel.data.trajectories) intel.data.trajectories = [];
        intel.data.trajectories.push(traj);
        delete trajectories[latestTrajId];

        // Learn from trajectory
        if (intel.engine && traj.steps.length > 0) {
          try {
            intel.engine.endTrajectory(latestTrajId, quality);
          } catch (e) { /* fallback */ }
        }

        intel.save();

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              trajectory_id: latestTrajId,
              steps: traj.steps.length,
              duration_ms: traj.endTime - traj.startTime,
              quality
            }, null, 2)
          }]
        };
      }

      case 'hooks_coedit_record': {
        const primaryFile = args.primary_file;
        const relatedFiles = args.related_files || [];

        if (!intel.data.coEditPatterns) intel.data.coEditPatterns = {};
        if (!intel.data.coEditPatterns[primaryFile]) intel.data.coEditPatterns[primaryFile] = {};

        for (const related of relatedFiles) {
          intel.data.coEditPatterns[primaryFile][related] = (intel.data.coEditPatterns[primaryFile][related] || 0) + 1;
        }

        // Use engine if available
        if (intel.engine) {
          try {
            for (const related of relatedFiles) {
              intel.engine.recordCoEdit(primaryFile, related);
            }
          } catch (e) { /* fallback */ }
        }

        intel.save();

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, primary_file: primaryFile, related_count: relatedFiles.length }, null, 2)
          }]
        };
      }

      case 'hooks_coedit_suggest': {
        const file = args.file;
        const topK = args.top_k || 5;

        let suggestions = [];

        // Try engine first
        if (intel.engine) {
          try {
            suggestions = intel.engine.getLikelyNextFiles(file, topK);
          } catch (e) { /* fallback */ }
        }

        // Fallback to data
        if (suggestions.length === 0 && intel.data.coEditPatterns && intel.data.coEditPatterns[file]) {
          suggestions = Object.entries(intel.data.coEditPatterns[file])
            .sort((a, b) => b[1] - a[1])
            .slice(0, topK)
            .map(([f, count]) => ({ file: f, count, confidence: count / 10 }));
        }

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, file, suggestions }, null, 2)
          }]
        };
      }

      case 'hooks_error_record': {
        const error = args.error;
        const fix = args.fix;
        const file = args.file || '';

        if (!intel.data.errors) intel.data.errors = {};
        if (!intel.data.errors[error]) intel.data.errors[error] = [];
        intel.data.errors[error].push({ fix, file, recorded: Date.now() });

        // Use engine if available
        if (intel.engine) {
          try {
            intel.engine.recordErrorFix(error, fix);
          } catch (e) { /* fallback */ }
        }

        intel.save();

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, error: error.substring(0, 50), fixes_recorded: intel.data.errors[error].length }, null, 2)
          }]
        };
      }

      case 'hooks_error_suggest': {
        const error = args.error;

        let suggestions = [];

        // Try engine first
        if (intel.engine) {
          try {
            suggestions = intel.engine.getSuggestedFixes(error);
          } catch (e) { /* fallback */ }
        }

        // Fallback to data
        if (suggestions.length === 0 && intel.data.errors) {
          // Find similar errors
          for (const [errKey, fixes] of Object.entries(intel.data.errors)) {
            if (error.includes(errKey) || errKey.includes(error)) {
              suggestions.push(...fixes.map(f => f.fix));
            }
          }
        }

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, error: error.substring(0, 50), suggestions: [...new Set(suggestions)].slice(0, 5) }, null, 2)
          }]
        };
      }

      case 'hooks_force_learn': {
        let result = 'Learning triggered';

        if (intel.engine) {
          try {
            // Run forceLearn on engine
            const learnResult = intel.engine.forceLearn();
            result = learnResult || 'Engine learning complete';

            // Also tick for regular updates
            intel.engine.tick();
          } catch (e) {
            result = `Learning: ${e.message}`;
          }
        }

        // Save any updates
        intel.save();

        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: true, result, stats: intel.stats() }, null, 2)
          }]
        };
      }

      // ============================================
      // NEW CAPABILITY TOOL HANDLERS
      // ============================================

      case 'hooks_ast_analyze': {
        try {
          const safeFile = sanitizeShellArg(args.file);
          const output = execSync(`npx ruvector hooks ast-analyze "${safeFile}" --json`, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_ast_complexity': {
        try {
          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
          const threshold = parseInt(args.threshold, 10) || 10;
          const output = execSync(`npx ruvector hooks ast-complexity ${filesArg} --threshold ${threshold}`, { encoding: 'utf-8', timeout: 60000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_diff_analyze': {
        try {
          const cmd = args.commit ? `npx ruvector hooks diff-analyze "${sanitizeShellArg(args.commit)}" --json` : 'npx ruvector hooks diff-analyze --json';
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 60000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_diff_classify': {
        try {
          const cmd = args.commit ? `npx ruvector hooks diff-classify "${sanitizeShellArg(args.commit)}"` : 'npx ruvector hooks diff-classify';
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_diff_similar': {
        try {
          const topK = parseInt(args.top_k, 10) || 5;
          const commits = parseInt(args.commits, 10) || 50;
          const output = execSync(`npx ruvector hooks diff-similar -k ${topK} --commits ${commits}`, { encoding: 'utf-8', timeout: 120000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_coverage_route': {
        try {
          const safeFile = sanitizeShellArg(args.file);
          const output = execSync(`npx ruvector hooks coverage-route "${safeFile}"`, { encoding: 'utf-8', timeout: 15000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_coverage_suggest': {
        try {
          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
          const output = execSync(`npx ruvector hooks coverage-suggest ${filesArg}`, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_graph_mincut': {
        try {
          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
          const output = execSync(`npx ruvector hooks graph-mincut ${filesArg}`, { encoding: 'utf-8', timeout: 60000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_graph_cluster': {
        try {
          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
          const method = sanitizeShellArg(args.method || 'louvain');
          const clusters = parseInt(args.clusters, 10) || 3;
          const output = execSync(`npx ruvector hooks graph-cluster ${filesArg} --method ${method} --clusters ${clusters}`, { encoding: 'utf-8', timeout: 60000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_security_scan': {
        try {
          const filesArg = args.files.map(f => `"${sanitizeShellArg(f)}"`).join(' ');
          const output = execSync(`npx ruvector hooks security-scan ${filesArg}`, { encoding: 'utf-8', timeout: 120000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_rag_context': {
        try {
          const safeQuery = sanitizeShellArg(args.query);
          const topK = parseInt(args.top_k, 10) || 5;
          let cmd = `npx ruvector hooks rag-context "${safeQuery}" -k ${topK}`;
          if (args.rerank) cmd += ' --rerank';
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_git_churn': {
        try {
          const days = parseInt(args.days, 10) || 30;
          const top = parseInt(args.top, 10) || 10;
          const output = execSync(`npx ruvector hooks git-churn --days ${days} --top ${top}`, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_route_enhanced': {
        try {
          const safeTask = sanitizeShellArg(args.task);
          let cmd = `npx ruvector hooks route-enhanced "${safeTask}"`;
          if (args.file) cmd += ` --file "${sanitizeShellArg(args.file)}"`;
          const output = execSync(cmd, { encoding: 'utf-8', timeout: 30000 });
          return { content: [{ type: 'text', text: output }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }] };
        }
      }

      case 'hooks_attention_info': {
        // Return info about available attention mechanisms
        let attentionInfo = { available: false, mechanisms: [] };
        try {
          const attention = require('@ruvector/attention');
          attentionInfo = {
            available: true,
            version: attention.version || '1.0.0',
            mechanisms: [
              { name: 'DotProductAttention', description: 'Basic scaled dot-product attention' },
              { name: 'MultiHeadAttention', description: 'Multi-head self-attention with parallel heads' },
              { name: 'FlashAttention', description: 'Memory-efficient attention with tiling' },
              { name: 'HyperbolicAttention', description: 'Attention in Poincaré ball hyperbolic space' },
              { name: 'LinearAttention', description: 'O(n) linear complexity attention' },
              { name: 'MoEAttention', description: 'Mixture-of-Experts sparse attention' },
              { name: 'GraphRoPeAttention', description: 'Rotary position embeddings for graphs' },
              { name: 'DualSpaceAttention', description: 'Euclidean + Hyperbolic hybrid' },
              { name: 'LocalGlobalAttention', description: 'Sliding window + global tokens' }
            ],
            hyperbolic: { expMap: true, logMap: true, mobiusAddition: true, poincareDistance: true }
          };
        } catch (e) {
          attentionInfo = { available: false, error: 'Attention package not installed' };
        }
        return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...attentionInfo }, null, 2) }] };
      }

      case 'hooks_gnn_info': {
        // Return info about GNN capabilities
        let gnnInfo = { available: false, layers: [] };
        try {
          const gnn = require('@ruvector/gnn');
          gnnInfo = {
            available: true,
            version: gnn.version || '1.0.0',
            layers: [
              { name: 'RuvectorLayer', description: 'Differentiable vector search layer' },
              { name: 'TensorCompress', description: 'Tensor compression for embeddings' }
            ],
            features: [
              'differentiableSearch - Gradient-based vector search',
              'hierarchicalForward - Multi-scale graph processing',
              'getCompressionLevel - Adaptive compression'
            ]
          };
        } catch (e) {
          gnnInfo = { available: false, error: 'GNN package not installed' };
        }
        return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...gnnInfo }, null, 2) }] };
      }

      // Learning Engine Handlers (v2.1)
      case 'hooks_learning_config': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const engine = new LearningEngine();
        if (intel.learning) engine.import(intel.learning);

        if (args.task && args.algorithm) {
          const config = {};
          if (args.algorithm) config.algorithm = args.algorithm;
          if (args.learningRate !== undefined) config.learningRate = args.learningRate;
          if (args.discountFactor !== undefined) config.discountFactor = args.discountFactor;
          if (args.epsilon !== undefined) config.epsilon = args.epsilon;
          engine.configure(args.task, config);
          intel.learning = engine.export();
          intel.save();
        }

        const tasks = ['agent-routing', 'error-avoidance', 'confidence-scoring', 'trajectory-learning', 'context-ranking', 'memory-recall'];
        const configs = {};
        for (const task of tasks) {
          configs[task] = engine.getConfig(task);
        }
        return { content: [{ type: 'text', text: JSON.stringify({ success: true, configs }, null, 2) }] };
      }

      case 'hooks_learning_stats': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const engine = new LearningEngine();
        if (intel.learning) engine.import(intel.learning);

        const summary = engine.getStatsSummary();
        return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...summary }, null, 2) }] };
      }

      case 'hooks_learning_update': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const engine = new LearningEngine();
        if (intel.learning) engine.import(intel.learning);

        const experience = {
          state: args.state,
          action: args.action,
          reward: args.reward,
          nextState: args.nextState || args.state,
          done: args.done || false,
          timestamp: Date.now()
        };

        const delta = engine.update(args.task, experience);
        intel.learning = engine.export();
        intel.save();

        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          task: args.task,
          experience,
          delta,
          algorithm: engine.getConfig(args.task).algorithm
        }, null, 2) }] };
      }

      case 'hooks_learn': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const engine = new LearningEngine();
        if (intel.learning) engine.import(intel.learning);

        const task = args.task || 'agent-routing';
        let result = { success: true };

        if (args.action && args.reward !== undefined) {
          const experience = {
            state: args.state,
            action: args.action,
            reward: args.reward,
            nextState: args.state,
            done: true,
            timestamp: Date.now()
          };
          const delta = engine.update(task, experience);
          result.recorded = { experience, delta, algorithm: engine.getConfig(task).algorithm };
        }

        if (args.actions && args.actions.length > 0) {
          const best = engine.getBestAction(task, args.state, args.actions);
          result.recommendation = best;
        }

        intel.learning = engine.export();
        intel.save();

        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
      }

      case 'hooks_algorithms_list': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const algorithms = LearningEngine.getAlgorithms();
        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          algorithms: algorithms.map(a => ({
            name: a.algorithm,
            description: a.description,
            bestFor: a.bestFor
          }))
        }, null, 2) }] };
      }

      // TensorCompress Handlers
      case 'hooks_compress': {
        let TensorCompress;
        try {
          TensorCompress = require('../dist/core/tensor-compress').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'TensorCompress not available' }) }] };
        }

        const compress = new TensorCompress({ autoCompress: false });
        if (intel.compressedPatterns) compress.import(intel.compressedPatterns);

        const stats = compress.recompressAll();
        intel.compressedPatterns = compress.export();
        intel.save();

        return { content: [{ type: 'text', text: JSON.stringify({ success: true, message: 'Compression complete', ...stats }, null, 2) }] };
      }

      case 'hooks_compress_stats': {
        let TensorCompress;
        try {
          TensorCompress = require('../dist/core/tensor-compress').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'TensorCompress not available' }) }] };
        }

        const compress = new TensorCompress({ autoCompress: false });
        if (intel.compressedPatterns) compress.import(intel.compressedPatterns);

        const stats = compress.getStats();
        return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...stats }, null, 2) }] };
      }

      case 'hooks_compress_store': {
        let TensorCompress;
        try {
          TensorCompress = require('../dist/core/tensor-compress').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'TensorCompress not available' }) }] };
        }

        const compress = new TensorCompress({ autoCompress: false });
        if (intel.compressedPatterns) compress.import(intel.compressedPatterns);

        compress.store(args.key, args.vector, args.level);
        intel.compressedPatterns = compress.export();
        intel.save();

        const stats = compress.getStats();
        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          key: args.key,
          level: args.level || 'auto',
          originalDim: args.vector.length,
          totalTensors: stats.totalTensors
        }, null, 2) }] };
      }

      case 'hooks_compress_get': {
        let TensorCompress;
        try {
          TensorCompress = require('../dist/core/tensor-compress').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'TensorCompress not available' }) }] };
        }

        const compress = new TensorCompress({ autoCompress: false });
        if (intel.compressedPatterns) compress.import(intel.compressedPatterns);

        const vector = compress.get(args.key);
        if (!vector) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Key not found' }) }] };
        }

        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          key: args.key,
          vector: Array.from(vector),
          dimension: vector.length
        }, null, 2) }] };
      }

      case 'hooks_batch_learn': {
        let LearningEngine;
        try {
          LearningEngine = require('../dist/core/learning-engine').default;
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'LearningEngine not available' }) }] };
        }

        const experiences = args.experiences || [];
        if (!Array.isArray(experiences) || experiences.length === 0) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'experiences must be a non-empty array' }) }] };
        }

        const task = args.task || 'agent-routing';
        const engine = new LearningEngine();

        // Import existing learning data
        if (intel.data.learning) {
          engine.import(intel.data.learning);
        }

        const results = [];
        let totalReward = 0;

        for (const exp of experiences) {
          const experience = {
            state: exp.state,
            action: exp.action,
            reward: exp.reward ?? 0.5,
            nextState: exp.nextState ?? exp.state,
            done: exp.done ?? false,
            timestamp: Date.now()
          };

          const delta = engine.update(task, experience);
          totalReward += experience.reward;
          results.push({ state: exp.state, action: exp.action, reward: experience.reward, delta });
        }

        // Save
        intel.data.learning = engine.export();
        intel.save();

        const stats = engine.getStatsSummary();
        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          processed: experiences.length,
          avgReward: totalReward / experiences.length,
          results,
          stats: {
            bestAlgorithm: stats.bestAlgorithm,
            totalUpdates: stats.totalUpdates,
            avgReward: stats.avgReward
          }
        }, null, 2) }] };
      }

      case 'hooks_subscribe_snapshot': {
        const events = args.events || ['learn', 'route'];
        const lastState = args.lastState || { patterns: 0, memories: 0, trajectories: 0, updates: 0 };

        const stats = intel.data.stats || {};
        const learning = intel.data.learning?.stats || {};

        // Calculate current state
        let totalUpdates = 0;
        let bestAlgorithm = null;
        let bestAvgReward = -Infinity;

        Object.entries(learning).forEach(([algo, data]) => {
          if (data.updates) {
            totalUpdates += data.updates;
            if (data.avgReward > bestAvgReward) {
              bestAvgReward = data.avgReward;
              bestAlgorithm = algo;
            }
          }
        });

        const currentState = {
          patterns: stats.total_patterns || 0,
          memories: stats.total_memories || 0,
          trajectories: stats.total_trajectories || 0,
          updates: totalUpdates
        };

        // Calculate deltas
        const deltas = {
          patterns: currentState.patterns - (lastState.patterns || 0),
          memories: currentState.memories - (lastState.memories || 0),
          trajectories: currentState.trajectories - (lastState.trajectories || 0),
          updates: currentState.updates - (lastState.updates || 0)
        };

        const hasChanges = Object.values(deltas).some(d => d > 0);

        // Build events array
        const eventsList = [];
        if (events.includes('learn') && deltas.patterns > 0) {
          eventsList.push({ type: 'learn', subtype: 'pattern', delta: deltas.patterns, total: currentState.patterns });
        }
        if (events.includes('learn') && deltas.updates > 0) {
          eventsList.push({ type: 'learn', subtype: 'algorithm', delta: deltas.updates, total: currentState.updates, bestAlgorithm });
        }
        if (events.includes('memory') && deltas.memories > 0) {
          eventsList.push({ type: 'memory', delta: deltas.memories, total: currentState.memories });
        }
        if (events.includes('route') && deltas.trajectories > 0) {
          eventsList.push({ type: 'route', delta: deltas.trajectories, total: currentState.trajectories });
        }

        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          hasChanges,
          currentState,
          deltas,
          events: eventsList,
          bestAlgorithm,
          timestamp: Date.now()
        }, null, 2) }] };
      }

      case 'hooks_watch_status': {
        // Return current intelligence state as a "watch" status
        const stats = intel.data.stats || {};
        const patterns = Object.keys(intel.data.patterns || {});
        const recentPatterns = patterns.slice(-5);

        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          watching: true,
          stats: {
            totalPatterns: stats.total_patterns || 0,
            totalMemories: stats.total_memories || 0,
            totalTrajectories: stats.total_trajectories || 0,
            sessionCount: stats.session_count || 0
          },
          recentPatterns,
          lastUpdate: stats.last_session || Date.now(),
          tip: 'Use hooks_subscribe_snapshot with lastState for delta tracking'
        }, null, 2) }] };
      }

      // ============================================
      // BACKGROUND WORKERS HANDLERS (via agentic-flow)
      // ============================================
      case 'workers_dispatch': {
        const prompt = sanitizeShellArg(args.prompt);
        try {
          const result = execSync(`npx agentic-flow@alpha workers dispatch "${prompt.replace(/"/g, '\\"')}"`, {
            encoding: 'utf-8',
            timeout: 30000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            message: 'Worker dispatched',
            output: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            message: 'Worker dispatch attempted',
            note: 'Check workers status for progress'
          }, null, 2) }] };
        }
      }

      case 'workers_status': {
        try {
          const cmdArgs = args.workerId ? `workers status ${sanitizeShellArg(args.workerId)}` : 'workers status';
          const result = execSync(`npx agentic-flow@alpha ${cmdArgs}`, {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            status: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: 'Could not get worker status',
            message: e.message
          }, null, 2) }] };
        }
      }

      case 'workers_results': {
        try {
          const cmdArgs = args.json ? 'workers results --json' : 'workers results';
          const result = execSync(`npx agentic-flow@alpha ${cmdArgs}`, {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          if (args.json) {
            try {
              return { content: [{ type: 'text', text: JSON.stringify({
                success: true,
                results: JSON.parse(result.trim())
              }, null, 2) }] };
            } catch {
              return { content: [{ type: 'text', text: result.trim() }] };
            }
          }
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            results: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: 'Could not get worker results',
            message: e.message
          }, null, 2) }] };
        }
      }

      case 'workers_triggers': {
        try {
          const result = execSync('npx agentic-flow@alpha workers triggers', {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            triggers: result.trim()
          }, null, 2) }] };
        } catch (e) {
          // Return hardcoded list as fallback
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            triggers: ['ultralearn', 'optimize', 'consolidate', 'predict', 'audit', 'map', 'preload', 'deepdive', 'document', 'refactor', 'benchmark', 'testgaps']
          }, null, 2) }] };
        }
      }

      case 'workers_stats': {
        try {
          const result = execSync('npx agentic-flow@alpha workers stats', {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            stats: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: 'Could not get worker stats',
            message: e.message
          }, null, 2) }] };
        }
      }

      // Custom Worker System handlers (agentic-flow@alpha.39+)
      case 'workers_presets': {
        try {
          const result = execSync('npx agentic-flow@alpha workers presets', {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            presets: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            presets: ['quick-scan', 'deep-analysis', 'security-scan', 'learning', 'api-docs', 'test-analysis'],
            note: 'Hardcoded fallback - install agentic-flow@alpha for full support'
          }, null, 2) }] };
        }
      }

      case 'workers_phases': {
        try {
          const result = execSync('npx agentic-flow@alpha workers phases', {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            phases: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            phases: ['file-discovery', 'static-analysis', 'security-analysis', 'pattern-extraction', 'dependency-analysis', 'complexity-analysis', 'test-coverage', 'api-extraction', 'secret-detection', 'report-generation'],
            note: 'Partial list - install agentic-flow@alpha for all 24 phases'
          }, null, 2) }] };
        }
      }

      case 'workers_create': {
        const name = args.name;
        const preset = args.preset || 'quick-scan';
        const triggers = args.triggers;
        try {
          let cmd = `npx agentic-flow@alpha workers create "${name}" --preset ${preset}`;
          if (triggers) cmd += ` --triggers "${triggers}"`;
          const result = execSync(cmd, {
            encoding: 'utf-8',
            timeout: 30000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            message: `Worker '${name}' created with preset '${preset}'`,
            output: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: 'Worker creation failed',
            message: e.message
          }, null, 2) }] };
        }
      }

      case 'workers_run': {
        const name = sanitizeShellArg(args.name);
        const targetPath = sanitizeShellArg(args.path || '.');
        try {
          const result = execSync(`npx agentic-flow@alpha workers run "${name}" --path "${targetPath}"`, {
            encoding: 'utf-8',
            timeout: 120000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            worker: name,
            path: targetPath,
            output: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: `Worker '${name}' execution failed`,
            message: e.message
          }, null, 2) }] };
        }
      }

      case 'workers_custom': {
        try {
          const result = execSync('npx agentic-flow@alpha workers custom', {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            workers: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            workers: [],
            note: 'No custom workers registered'
          }, null, 2) }] };
        }
      }

      case 'workers_init_config': {
        try {
          let cmd = 'npx agentic-flow@alpha workers init-config';
          if (args.force) cmd += ' --force';
          const result = execSync(cmd, {
            encoding: 'utf-8',
            timeout: 15000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            message: 'workers.yaml config file created',
            output: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: 'Config init failed',
            message: e.message
          }, null, 2) }] };
        }
      }

      case 'workers_load_config': {
        const configFile = sanitizeShellArg(args.file || 'workers.yaml');
        try {
          const result = execSync(`npx agentic-flow@alpha workers load-config --file "${configFile}"`, {
            encoding: 'utf-8',
            timeout: 30000,
            stdio: ['pipe', 'pipe', 'pipe']
          });
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            file: configFile,
            output: result.trim()
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: `Config load failed from '${configFile}'`,
            message: e.message
          }, null, 2) }] };
        }
      }

      // ── RVF Tool Handlers ─────────────────────────────────────────────────
      case 'rvf_create': {
        try {
          const safePath = validateRvfPath(args.path);
          const { createRvfStore } = require('../dist/core/rvf-wrapper.js');
          const store = await createRvfStore(safePath, { dimension: args.dimension, metric: args.metric || 'cosine' });
          const status = store.status ? await store.status() : { dimension: args.dimension };
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, path: safePath, ...status }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message, hint: 'Install @ruvector/rvf: npm install @ruvector/rvf' }, null, 2) }], isError: true };
        }
      }

      case 'rvf_open': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfStatus } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const status = await rvfStatus(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, path: safePath, ...status }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_ingest': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfIngest, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const result = await rvfIngest(store, args.entries);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_query': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfQuery, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const results = await rvfQuery(store, args.vector, args.k || 10);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, results }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_delete': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfDelete, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const result = await rvfDelete(store, args.ids);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_status': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfStatus, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const status = await rvfStatus(store);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...status }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_compact': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfCompact, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const result = await rvfCompact(store);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, ...result }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_derive': {
        try {
          const safeParent = validateRvfPath(args.parent_path);
          const safeChild = validateRvfPath(args.child_path);
          const { openRvfStore, rvfDerive, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safeParent);
          await rvfDerive(store, safeChild);
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, parent: safeParent, child: safeChild }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_segments': {
        try {
          const safePath = validateRvfPath(args.path);
          const { openRvfStore, rvfClose } = require('../dist/core/rvf-wrapper.js');
          const store = await openRvfStore(safePath);
          const segs = await store.segments();
          await rvfClose(store);
          return { content: [{ type: 'text', text: JSON.stringify({ success: true, segments: segs }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: e.message }, null, 2) }], isError: true };
        }
      }

      case 'rvf_examples': {
        const BASE_URL = 'https://raw.githubusercontent.com/ruvnet/ruvector/main/examples/rvf/output';
        const examples = [
          { name: 'basic_store', size: '152 KB', desc: '1,000 vectors, dim 128' },
          { name: 'semantic_search', size: '755 KB', desc: 'Semantic search with HNSW' },
          { name: 'rag_pipeline', size: '303 KB', desc: 'RAG pipeline embeddings' },
          { name: 'agent_memory', size: '32 KB', desc: 'AI agent episodic memory' },
          { name: 'swarm_knowledge', size: '86 KB', desc: 'Multi-agent knowledge base' },
          { name: 'self_booting', size: '31 KB', desc: 'Self-booting with kernel' },
          { name: 'ebpf_accelerator', size: '153 KB', desc: 'eBPF distance accelerator' },
          { name: 'tee_attestation', size: '102 KB', desc: 'TEE attestation + witnesses' },
          { name: 'lineage_parent', size: '52 KB', desc: 'COW parent file' },
          { name: 'lineage_child', size: '26 KB', desc: 'COW child (derived)' },
          { name: 'claude_code_appliance', size: '17 KB', desc: 'Claude Code appliance' },
          { name: 'progressive_index', size: '2.5 MB', desc: 'Large-scale HNSW index' },
        ];
        let filtered = examples;
        if (args.filter) {
          const f = args.filter.toLowerCase();
          filtered = examples.filter(e => e.name.includes(f) || e.desc.toLowerCase().includes(f));
        }
        return { content: [{ type: 'text', text: JSON.stringify({
          success: true,
          total: 45,
          shown: filtered.length,
          examples: filtered.map(e => ({ ...e, url: `${BASE_URL}/${e.name}.rvf` })),
          catalog: 'https://github.com/ruvnet/ruvector/tree/main/examples/rvf/output'
        }, null, 2) }] };
      }

      // ── rvlite Query Tool Handlers ──────────────────────────────────────
      case 'rvlite_sql': {
        try {
          let rvlite;
          try {
            rvlite = require('rvlite');
          } catch (_e) {
            return { content: [{ type: 'text', text: JSON.stringify({
              success: false,
              error: 'rvlite package not installed',
              hint: 'Install with: npm install rvlite'
            }, null, 2) }] };
          }
          const safeQuery = sanitizeShellArg(args.query);
          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
          const db = new rvlite.Database(dbOpts);
          const results = db.sql(safeQuery);
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            query_type: 'sql',
            results,
            row_count: Array.isArray(results) ? results.length : 0
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: e.message
          }, null, 2) }], isError: true };
        }
      }

      case 'rvlite_cypher': {
        try {
          let rvlite;
          try {
            rvlite = require('rvlite');
          } catch (_e) {
            return { content: [{ type: 'text', text: JSON.stringify({
              success: false,
              error: 'rvlite package not installed',
              hint: 'Install with: npm install rvlite'
            }, null, 2) }] };
          }
          const safeQuery = sanitizeShellArg(args.query);
          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
          const db = new rvlite.Database(dbOpts);
          const results = db.cypher(safeQuery);
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            query_type: 'cypher',
            results,
            row_count: Array.isArray(results) ? results.length : 0
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: e.message
          }, null, 2) }], isError: true };
        }
      }

      case 'rvlite_sparql': {
        try {
          let rvlite;
          try {
            rvlite = require('rvlite');
          } catch (_e) {
            return { content: [{ type: 'text', text: JSON.stringify({
              success: false,
              error: 'rvlite package not installed',
              hint: 'Install with: npm install rvlite'
            }, null, 2) }] };
          }
          const safeQuery = sanitizeShellArg(args.query);
          const dbOpts = args.db_path ? { path: validateRvfPath(args.db_path) } : {};
          const db = new rvlite.Database(dbOpts);
          const results = db.sparql(safeQuery);
          return { content: [{ type: 'text', text: JSON.stringify({
            success: true,
            query_type: 'sparql',
            results,
            row_count: Array.isArray(results) ? results.length : 0
          }, null, 2) }] };
        } catch (e) {
          return { content: [{ type: 'text', text: JSON.stringify({
            success: false,
            error: e.message
          }, null, 2) }], isError: true };
        }
      }

      default:
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({ success: false, error: `Unknown tool: ${name}` }, null, 2)
          }],
          isError: true
        };
    }
  } catch (error) {
    return {
      content: [{
        type: 'text',
        text: JSON.stringify({ success: false, error: error.message }, null, 2)
      }],
      isError: true
    };
  }
});

// Resources - expose intelligence data
server.setRequestHandler(ListResourcesRequestSchema, async () => {
  return {
    resources: [
      {
        uri: 'ruvector://intelligence/stats',
        name: 'Intelligence Stats',
        description: 'Current RuVector intelligence statistics',
        mimeType: 'application/json'
      },
      {
        uri: 'ruvector://intelligence/patterns',
        name: 'Learned Patterns',
        description: 'Q-learning patterns for agent routing',
        mimeType: 'application/json'
      },
      {
        uri: 'ruvector://intelligence/memories',
        name: 'Vector Memories',
        description: 'Stored context memories',
        mimeType: 'application/json'
      }
    ]
  };
});

server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
  const { uri } = request.params;

  switch (uri) {
    case 'ruvector://intelligence/stats':
      return {
        contents: [{
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(intel.stats(), null, 2)
        }]
      };

    case 'ruvector://intelligence/patterns':
      return {
        contents: [{
          uri,
          mimeType: 'application/json',
          text: JSON.stringify(intel.data.patterns || {}, null, 2)
        }]
      };

    case 'ruvector://intelligence/memories':
      return {
        contents: [{
          uri,
          mimeType: 'application/json',
          text: JSON.stringify((intel.data.memories || []).map(m => ({
            content: m.content,
            type: m.type,
            created: m.created
          })), null, 2)
        }]
      };

    default:
      throw new Error(`Unknown resource: ${uri}`);
  }
});

// Start server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('RuVector MCP server running on stdio');
}

main().catch(console.error);