claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/mcp/mcp-server.js

@@ -3,1552 +3,1688 @@
  * ⚠️ DEPRECATED: MCP server has been removed in v2.0.0
  * Please use: claude-flow-novice start
  * See: MCP_DEPRECATION_NOTICE.md
- */
-require('./DEPRECATED.js');
+ */ require('./DEPRECATED.js');
 process.exit(1);
-
-/* LEGACY CODE - NON-FUNCTIONAL
- * Claude-Flow MCP Server
- * Implements the Model Context Protocol for Claude-Flow v2.0.0
- * Compatible with ruv-swarm MCP interface
- */
-
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { EnhancedMemory } from '../memory/enhanced-memory.js';
+import path from "path";
+import { fileURLToPath } from "url";
 // Use the same memory system that npx commands use - singleton instance
-import { memoryStore } from '../memory/fallback-store.js';
-
+import { memoryStore } from "../memory/fallback-store.js";
 // Initialize agent tracker
-await import('./implementations/agent-tracker.js').catch(() => {
-  // If ES module import fails, try require
-  try {
-    require('./implementations/agent-tracker');
-  } catch (e) {
-    console.log('Agent tracker not loaded');
-  }
+await import("./implementations/agent-tracker.js").catch(()=>{
+    // If ES module import fails, try require
+    try {
+        require('./implementations/agent-tracker');
+    } catch (e) {
+        console.log('Agent tracker not loaded');
+    }
 });
-
 // Initialize DAA manager
-await import('./implementations/daa-tools.js').catch(() => {
-  // If ES module import fails, try require
-  try {
-    require('./implementations/daa-tools');
-  } catch (e) {
-    console.log('DAA manager not loaded');
-  }
+await import("./implementations/daa-tools.js").catch(()=>{
+    // If ES module import fails, try require
+    try {
+        require('./implementations/daa-tools');
+    } catch (e) {
+        console.log('DAA manager not loaded');
+    }
 });
-
 // Initialize Workflow and Performance managers
-await import('./implementations/workflow-tools.js').catch(() => {
-  // If ES module import fails, try require
-  try {
-    require('./implementations/workflow-tools');
-  } catch (e) {
-    console.log('Workflow tools not loaded');
-  }
+await import("./implementations/workflow-tools.js").catch(()=>{
+    // If ES module import fails, try require
+    try {
+        require('./implementations/workflow-tools');
+    } catch (e) {
+        console.log('Workflow tools not loaded');
+    }
 });
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-
 // Legacy agent type mapping for backward compatibility
 const LEGACY_AGENT_MAPPING = {
-  analyst: 'code-analyzer',
-  coordinator: 'task-orchestrator',
-  optimizer: 'perf-analyzer',
-  documenter: 'api-docs',
-  monitor: 'performance-benchmarker',
-  specialist: 'system-architect',
-  architect: 'system-architect',
+    analyst: 'code-analyzer',
+    coordinator: 'task-orchestrator',
+    optimizer: 'perf-analyzer',
+    documenter: 'api-docs',
+    monitor: 'performance-benchmarker',
+    specialist: 'system-architect',
+    architect: 'system-architect'
 };
-
 // Resolve legacy agent types to current equivalents
 function resolveLegacyAgentType(legacyType) {
-  return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
+    return LEGACY_AGENT_MAPPING[legacyType] || legacyType;
 }
-
-class ClaudeFlowMCPServer {
-  constructor() {
-    this.version = '2.0.0-alpha.59';
-    this.memoryStore = memoryStore; // Use shared singleton instance
-    // Use the same memory system that already works
-    this.capabilities = {
-      tools: {
-        listChanged: true,
-      },
-      resources: {
-        subscribe: true,
-        listChanged: true,
-      },
-    };
-    this.sessionId = `session-cf-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`;
-    this.tools = this.initializeTools();
-    this.resources = this.initializeResources();
-
-    // Initialize shared memory store (same as npx commands)
-    this.initializeMemory().catch((err) => {
-      console.error(
-        `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to initialize shared memory:`,
-        err,
-      );
-    });
-
-    // Database operations now use the same shared memory store as npx commands
-  }
-
-  async initializeMemory() {
-    await this.memoryStore.initialize();
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) Shared memory store initialized (same as npx)`,
-    );
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) Using ${this.memoryStore.isUsingFallback() ? 'in-memory' : 'SQLite'} storage`,
-    );
-  }
-
-  // Database operations now use the same memory store as working npx commands
-
-  initializeTools() {
-    return {
-      // Swarm Coordination Tools (12)
-      swarm_init: {
-        name: 'swarm_init',
-        description: 'Initialize swarm with topology and configuration',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            topology: { type: 'string', enum: ['hierarchical', 'mesh', 'ring', 'star'] },
-            maxAgents: { type: 'number', default: 8 },
-            strategy: { type: 'string', default: 'auto' },
-          },
-          required: ['topology'],
-        },
-      },
-      agent_spawn: {
-        name: 'agent_spawn',
-        description: 'Create specialized AI agents',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            type: {
-              type: 'string',
-              enum: [
-                // Legacy types (for backward compatibility)
-                'coordinator',
-                'analyst',
-                'optimizer',
-                'documenter',
-                'monitor',
-                'specialist',
-                'architect',
-                // Current types
-                'task-orchestrator',
-                'code-analyzer',
-                'perf-analyzer',
-                'api-docs',
-                'performance-benchmarker',
-                'system-architect',
-                // Core types
-                'researcher',
-                'coder',
-                'tester',
-                'reviewer',
-              ],
-            },
-            name: { type: 'string' },
-            capabilities: { type: 'array' },
-            swarmId: { type: 'string' },
-          },
-          required: ['type'],
-        },
-      },
-      task_orchestrate: {
-        name: 'task_orchestrate',
-        description: 'Orchestrate complex task workflows',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            task: { type: 'string' },
-            strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive', 'balanced'] },
-            priority: { type: 'string', enum: ['low', 'medium', 'high', 'critical'] },
-            dependencies: { type: 'array' },
-          },
-          required: ['task'],
-        },
-      },
-      swarm_status: {
-        name: 'swarm_status',
-        description: 'Monitor swarm health and performance',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            swarmId: { type: 'string' },
-          },
-        },
-      },
-
-      // Neural Network Tools - DEPRECATED: Advanced neural features hidden from novice users
-      // Retained: neural_status, neural_train, neural_patterns (basic functionality)
-      // Use memory_usage for pattern storage instead of neural-specific tools
-
-      // Memory & Persistence Tools (12)
-      memory_usage: {
-        name: 'memory_usage',
-        description: 'Store/retrieve persistent memory with TTL and namespacing',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            action: { type: 'string', enum: ['store', 'retrieve', 'list', 'delete', 'search'] },
-            key: { type: 'string' },
-            value: { type: 'string' },
-            namespace: { type: 'string', default: 'default' },
-            ttl: { type: 'number' },
-          },
-          required: ['action'],
-        },
-      },
-      memory_search: {
-        name: 'memory_search',
-        description: 'Search memory with patterns',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            pattern: { type: 'string' },
-            namespace: { type: 'string' },
-            limit: { type: 'number', default: 10 },
-          },
-          required: ['pattern'],
-        },
-      },
-
-      // Analysis & Monitoring Tools (13)
-      performance_report: {
-        name: 'performance_report',
-        description: 'Generate performance reports with real-time metrics',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            timeframe: { type: 'string', enum: ['24h', '7d', '30d'], default: '24h' },
-            format: { type: 'string', enum: ['summary', 'detailed', 'json'], default: 'summary' },
-          },
-        },
-      },
-      bottleneck_analyze: {
-        name: 'bottleneck_analyze',
-        description: 'Identify performance bottlenecks',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            component: { type: 'string' },
-            metrics: { type: 'array' },
-          },
-        },
-      },
-      token_usage: {
-        name: 'token_usage',
-        description: 'Analyze token consumption',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            operation: { type: 'string' },
-            timeframe: { type: 'string', default: '24h' },
-          },
-        },
-      },
-
-      // GitHub Integration Tools (8)
-      github_repo_analyze: {
-        name: 'github_repo_analyze',
-        description: 'Repository analysis',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            repo: { type: 'string' },
-            analysis_type: { type: 'string', enum: ['code_quality', 'performance', 'security'] },
-          },
-          required: ['repo'],
-        },
-      },
-      github_pr_manage: {
-        name: 'github_pr_manage',
-        description: 'Pull request management',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            repo: { type: 'string' },
-            pr_number: { type: 'number' },
-            action: { type: 'string', enum: ['review', 'merge', 'close'] },
-          },
-          required: ['repo', 'action'],
-        },
-      },
-
-      // DAA Tools - DEPRECATED: Tools removed, functionality integrated into swarm_init and agent_spawn
-      // Legacy tools daa_agent_create and daa_capability_match have been consolidated
-
-      // Workflow Tools (11)
-      workflow_create: {
-        name: 'workflow_create',
-        description: 'Create custom workflows',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            steps: { type: 'array' },
-            triggers: { type: 'array' },
-          },
-          required: ['name', 'steps'],
-        },
-      },
-      sparc_mode: {
-        name: 'sparc_mode',
-        description: 'Run SPARC development modes',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            mode: { type: 'string', enum: ['dev', 'api', 'ui', 'test', 'refactor'] },
-            task_description: { type: 'string' },
-            options: { type: 'object' },
-          },
-          required: ['mode', 'task_description'],
-        },
-      },
-
-      // Additional Swarm Tools
-      agent_list: {
-        name: 'agent_list',
-        description: 'List active agents & capabilities',
-        inputSchema: { type: 'object', properties: { swarmId: { type: 'string' } } },
-      },
-      agent_metrics: {
-        name: 'agent_metrics',
-        description: 'Agent performance metrics',
-        inputSchema: { type: 'object', properties: { agentId: { type: 'string' } } },
-      },
-      swarm_monitor: {
-        name: 'swarm_monitor',
-        description: 'Real-time swarm monitoring',
-        inputSchema: {
-          type: 'object',
-          properties: { swarmId: { type: 'string' }, interval: { type: 'number' } },
-        },
-      },
-      topology_optimize: {
-        name: 'topology_optimize',
-        description: 'Auto-optimize swarm topology',
-        inputSchema: { type: 'object', properties: { swarmId: { type: 'string' } } },
-      },
-      load_balance: {
-        name: 'load_balance',
-        description: 'Distribute tasks efficiently',
-        inputSchema: {
-          type: 'object',
-          properties: { swarmId: { type: 'string' }, tasks: { type: 'array' } },
-        },
-      },
-      coordination_sync: {
-        name: 'coordination_sync',
-        description: 'Sync agent coordination',
-        inputSchema: { type: 'object', properties: { swarmId: { type: 'string' } } },
-      },
-      swarm_scale: {
-        name: 'swarm_scale',
-        description: 'Auto-scale agent count',
-        inputSchema: {
-          type: 'object',
-          properties: { swarmId: { type: 'string' }, targetSize: { type: 'number' } },
-        },
-      },
-      swarm_destroy: {
-        name: 'swarm_destroy',
-        description: 'Gracefully shutdown swarm',
-        inputSchema: {
-          type: 'object',
-          properties: { swarmId: { type: 'string' } },
-          required: ['swarmId'],
-        },
-      },
-
-      // Additional Neural Tools - DEPRECATED: Removed 13 advanced neural tools
-      // Tools removed: neural_predict, model_load, model_save, wasm_optimize, inference_run,
-      // pattern_recognize, cognitive_analyze, learning_adapt, neural_compress, ensemble_create,
-      // transfer_learn, neural_explain
-      // Rationale: Complexity reduction for novice users, functionality available via plugins
-
-      // Additional Memory Tools - DEPRECATED: Removed 10 advanced memory management tools
-      // Tools removed: memory_persist, memory_namespace, memory_backup, memory_restore,
-      // memory_compress, memory_sync, cache_manage, state_snapshot, context_restore, memory_analytics
-      // Retained: memory_usage, memory_search (core functionality)
-      // Rationale: Simplified memory interface, basic features in memory_usage sufficient
-
-      // Additional Analysis Tools
-      task_status: {
-        name: 'task_status',
-        description: 'Check task execution status',
-        inputSchema: {
-          type: 'object',
-          properties: { taskId: { type: 'string' } },
-          required: ['taskId'],
-        },
-      },
-      task_results: {
-        name: 'task_results',
-        description: 'Get task completion results',
-        inputSchema: {
-          type: 'object',
-          properties: { taskId: { type: 'string' } },
-          required: ['taskId'],
-        },
-      },
-      benchmark_run: {
-        name: 'benchmark_run',
-        description: 'Performance benchmarks',
-        inputSchema: { type: 'object', properties: { suite: { type: 'string' } } },
-      },
-      metrics_collect: {
-        name: 'metrics_collect',
-        description: 'Collect system metrics',
-        inputSchema: { type: 'object', properties: { components: { type: 'array' } } },
-      },
-      trend_analysis: {
-        name: 'trend_analysis',
-        description: 'Analyze performance trends',
-        inputSchema: {
-          type: 'object',
-          properties: { metric: { type: 'string' }, period: { type: 'string' } },
-          required: ['metric'],
-        },
-      },
-      cost_analysis: {
-        name: 'cost_analysis',
-        description: 'Cost and resource analysis',
-        inputSchema: { type: 'object', properties: { timeframe: { type: 'string' } } },
-      },
-      quality_assess: {
-        name: 'quality_assess',
-        description: 'Quality assessment',
-        inputSchema: {
-          type: 'object',
-          properties: { target: { type: 'string' }, criteria: { type: 'array' } },
-          required: ['target'],
-        },
-      },
-      error_analysis: {
-        name: 'error_analysis',
-        description: 'Error pattern analysis',
-        inputSchema: { type: 'object', properties: { logs: { type: 'array' } } },
-      },
-      usage_stats: {
-        name: 'usage_stats',
-        description: 'Usage statistics',
-        inputSchema: { type: 'object', properties: { component: { type: 'string' } } },
-      },
-      health_check: {
-        name: 'health_check',
-        description: 'System health monitoring',
-        inputSchema: { type: 'object', properties: { components: { type: 'array' } } },
-      },
-
-      // Additional Workflow Tools - DEPRECATED: Removed 9 workflow automation tools
-      // Tools removed: workflow_execute, workflow_export, automation_setup, pipeline_create,
-      // scheduler_manage, trigger_setup, workflow_template, batch_process, parallel_execute
-      // Retained: workflow_create (basic functionality)
-      // Rationale: Workflow execution integrated into task_orchestrate, reduces tool count
-
-      // GitHub Integration Tools
-      github_issue_track: {
-        name: 'github_issue_track',
-        description: 'Issue tracking & triage',
-        inputSchema: {
-          type: 'object',
-          properties: { repo: { type: 'string' }, action: { type: 'string' } },
-          required: ['repo', 'action'],
-        },
-      },
-      github_release_coord: {
-        name: 'github_release_coord',
-        description: 'Release coordination',
-        inputSchema: {
-          type: 'object',
-          properties: { repo: { type: 'string' }, version: { type: 'string' } },
-          required: ['repo', 'version'],
-        },
-      },
-      github_workflow_auto: {
-        name: 'github_workflow_auto',
-        description: 'Workflow automation',
-        inputSchema: {
-          type: 'object',
-          properties: { repo: { type: 'string' }, workflow: { type: 'object' } },
-          required: ['repo', 'workflow'],
-        },
-      },
-      github_code_review: {
-        name: 'github_code_review',
-        description: 'Automated code review',
-        inputSchema: {
-          type: 'object',
-          properties: { repo: { type: 'string' }, pr: { type: 'number' } },
-          required: ['repo', 'pr'],
-        },
-      },
-      github_sync_coord: {
-        name: 'github_sync_coord',
-        description: 'Multi-repo sync coordination',
-        inputSchema: {
-          type: 'object',
-          properties: { repos: { type: 'array' } },
-          required: ['repos'],
-        },
-      },
-      github_metrics: {
-        name: 'github_metrics',
-        description: 'Repository metrics',
-        inputSchema: {
-          type: 'object',
-          properties: { repo: { type: 'string' } },
-          required: ['repo'],
-        },
-      },
-
-      // Additional DAA Tools - DEPRECATED: Removed 6 advanced DAA tools
-      // Tools removed: daa_resource_alloc, daa_lifecycle_manage, daa_communication,
-      // daa_consensus, daa_fault_tolerance, daa_optimization
-      // Rationale: DAA functionality consolidated into core swarm tools (swarm_init, agent_spawn, task_orchestrate)
-
-      // System & Utilities Tools - DEPRECATED: Removed 8 system utility tools
-      // Tools removed: terminal_execute, config_manage, features_detect, security_scan,
-      // backup_create, restore_system, log_analysis, diagnostic_run
-      // Rationale: Terminal execution insecure for MCP, other tools redundant with CLI commands
-      // Note: features_detect retained in limited scope for framework detection only
-    };
-  }
-
-  initializeResources() {
-    return {
-      'claude-flow://swarms': {
-        uri: 'claude-flow://swarms',
-        name: 'Active Swarms',
-        description: 'List of active swarm configurations and status',
-        mimeType: 'application/json',
-      },
-      'claude-flow://agents': {
-        uri: 'claude-flow://agents',
-        name: 'Agent Registry',
-        description: 'Registry of available agents and their capabilities',
-        mimeType: 'application/json',
-      },
-      'claude-flow://models': {
-        uri: 'claude-flow://models',
-        name: 'Neural Models',
-        description: 'Available neural network models and training status',
-        mimeType: 'application/json',
-      },
-      'claude-flow://performance': {
-        uri: 'claude-flow://performance',
-        name: 'Performance Metrics',
-        description: 'Real-time performance metrics and benchmarks',
-        mimeType: 'application/json',
-      },
-    };
-  }
-
-  async handleMessage(message) {
-    try {
-      const { id, method, params } = message;
-
-      switch (method) {
-        case 'initialize':
-          return this.handleInitialize(id, params);
-        case 'tools/list':
-          return this.handleToolsList(id);
-        case 'tools/call':
-          return this.handleToolCall(id, params);
-        case 'resources/list':
-          return this.handleResourcesList(id);
-        case 'resources/read':
-          return this.handleResourceRead(id, params);
-        default:
-          return this.createErrorResponse(id, -32601, 'Method not found');
-      }
-    } catch (error) {
-      return this.createErrorResponse(message.id, -32603, 'Internal error', error.message);
+let ClaudeFlowMCPServer = class ClaudeFlowMCPServer {
+    async initializeMemory() {
+        await this.memoryStore.initialize();
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) Shared memory store initialized (same as npx)`);
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) Using ${this.memoryStore.isUsingFallback() ? 'in-memory' : 'SQLite'} storage`);
     }
-  }
-
-  handleInitialize(id, params) {
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) 🔌 Connection established: ${this.sessionId}`,
-    );
-
-    return {
-      jsonrpc: '2.0',
-      id,
-      result: {
-        protocolVersion: '2024-11-05',
-        capabilities: this.capabilities,
-        serverInfo: {
-          name: 'claude-flow',
-          version: this.version,
-        },
-      },
-    };
-  }
-
-  handleToolsList(id) {
-    const toolsList = Object.values(this.tools);
-    return {
-      jsonrpc: '2.0',
-      id,
-      result: {
-        tools: toolsList,
-      },
-    };
-  }
-
-  async handleToolCall(id, params) {
-    const { name, arguments: args } = params;
-
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) 🔧 Tool called: ${name}`,
-    );
-
-    try {
-      const result = await this.executeTool(name, args);
-      return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result, null, 2),
+    // Database operations now use the same memory store as working npx commands
+    initializeTools() {
+        return {
+            // Swarm Coordination Tools (12)
+            swarm_init: {
+                name: 'swarm_init',
+                description: 'Initialize swarm with topology and configuration',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        topology: {
+                            type: 'string',
+                            enum: [
+                                'hierarchical',
+                                'mesh',
+                                'ring',
+                                'star'
+                            ]
+                        },
+                        maxAgents: {
+                            type: 'number',
+                            default: 8
+                        },
+                        strategy: {
+                            type: 'string',
+                            default: 'auto'
+                        }
+                    },
+                    required: [
+                        'topology'
+                    ]
+                }
             },
-          ],
-        },
-      };
-    } catch (error) {
-      return this.createErrorResponse(id, -32000, 'Tool execution failed', error.message);
-    }
-  }
-
-  handleResourcesList(id) {
-    const resourcesList = Object.values(this.resources);
-    return {
-      jsonrpc: '2.0',
-      id,
-      result: {
-        resources: resourcesList,
-      },
-    };
-  }
-
-  async handleResourceRead(id, params) {
-    const { uri } = params;
-
-    try {
-      const content = await this.readResource(uri);
-      return {
-        jsonrpc: '2.0',
-        id,
-        result: {
-          contents: [
-            {
-              uri,
-              mimeType: 'application/json',
-              text: JSON.stringify(content, null, 2),
+            agent_spawn: {
+                name: 'agent_spawn',
+                description: 'Create specialized AI agents',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        type: {
+                            type: 'string',
+                            enum: [
+                                // Legacy types (for backward compatibility)
+                                'coordinator',
+                                'analyst',
+                                'optimizer',
+                                'documenter',
+                                'monitor',
+                                'specialist',
+                                'architect',
+                                // Current types
+                                'task-orchestrator',
+                                'code-analyzer',
+                                'perf-analyzer',
+                                'api-docs',
+                                'performance-benchmarker',
+                                'system-architect',
+                                // Core types
+                                'researcher',
+                                'coder',
+                                'tester',
+                                'reviewer'
+                            ]
+                        },
+                        name: {
+                            type: 'string'
+                        },
+                        capabilities: {
+                            type: 'array'
+                        },
+                        swarmId: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'type'
+                    ]
+                }
+            },
+            task_orchestrate: {
+                name: 'task_orchestrate',
+                description: 'Orchestrate complex task workflows',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        task: {
+                            type: 'string'
+                        },
+                        strategy: {
+                            type: 'string',
+                            enum: [
+                                'parallel',
+                                'sequential',
+                                'adaptive',
+                                'balanced'
+                            ]
+                        },
+                        priority: {
+                            type: 'string',
+                            enum: [
+                                'low',
+                                'medium',
+                                'high',
+                                'critical'
+                            ]
+                        },
+                        dependencies: {
+                            type: 'array'
+                        }
+                    },
+                    required: [
+                        'task'
+                    ]
+                }
+            },
+            swarm_status: {
+                name: 'swarm_status',
+                description: 'Monitor swarm health and performance',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            // Neural Network Tools - DEPRECATED: Advanced neural features hidden from novice users
+            // Retained: neural_status, neural_train, neural_patterns (basic functionality)
+            // Use memory_usage for pattern storage instead of neural-specific tools
+            // Memory & Persistence Tools (12)
+            memory_usage: {
+                name: 'memory_usage',
+                description: 'Store/retrieve persistent memory with TTL and namespacing',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        action: {
+                            type: 'string',
+                            enum: [
+                                'store',
+                                'retrieve',
+                                'list',
+                                'delete',
+                                'search'
+                            ]
+                        },
+                        key: {
+                            type: 'string'
+                        },
+                        value: {
+                            type: 'string'
+                        },
+                        namespace: {
+                            type: 'string',
+                            default: 'default'
+                        },
+                        ttl: {
+                            type: 'number'
+                        }
+                    },
+                    required: [
+                        'action'
+                    ]
+                }
+            },
+            memory_search: {
+                name: 'memory_search',
+                description: 'Search memory with patterns',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        pattern: {
+                            type: 'string'
+                        },
+                        namespace: {
+                            type: 'string'
+                        },
+                        limit: {
+                            type: 'number',
+                            default: 10
+                        }
+                    },
+                    required: [
+                        'pattern'
+                    ]
+                }
+            },
+            // Analysis & Monitoring Tools (13)
+            performance_report: {
+                name: 'performance_report',
+                description: 'Generate performance reports with real-time metrics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        timeframe: {
+                            type: 'string',
+                            enum: [
+                                '24h',
+                                '7d',
+                                '30d'
+                            ],
+                            default: '24h'
+                        },
+                        format: {
+                            type: 'string',
+                            enum: [
+                                'summary',
+                                'detailed',
+                                'json'
+                            ],
+                            default: 'summary'
+                        }
+                    }
+                }
+            },
+            bottleneck_analyze: {
+                name: 'bottleneck_analyze',
+                description: 'Identify performance bottlenecks',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        component: {
+                            type: 'string'
+                        },
+                        metrics: {
+                            type: 'array'
+                        }
+                    }
+                }
+            },
+            token_usage: {
+                name: 'token_usage',
+                description: 'Analyze token consumption',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        operation: {
+                            type: 'string'
+                        },
+                        timeframe: {
+                            type: 'string',
+                            default: '24h'
+                        }
+                    }
+                }
+            },
+            // GitHub Integration Tools (8)
+            github_repo_analyze: {
+                name: 'github_repo_analyze',
+                description: 'Repository analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        analysis_type: {
+                            type: 'string',
+                            enum: [
+                                'code_quality',
+                                'performance',
+                                'security'
+                            ]
+                        }
+                    },
+                    required: [
+                        'repo'
+                    ]
+                }
+            },
+            github_pr_manage: {
+                name: 'github_pr_manage',
+                description: 'Pull request management',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        pr_number: {
+                            type: 'number'
+                        },
+                        action: {
+                            type: 'string',
+                            enum: [
+                                'review',
+                                'merge',
+                                'close'
+                            ]
+                        }
+                    },
+                    required: [
+                        'repo',
+                        'action'
+                    ]
+                }
+            },
+            // DAA Tools - DEPRECATED: Tools removed, functionality integrated into swarm_init and agent_spawn
+            // Legacy tools daa_agent_create and daa_capability_match have been consolidated
+            // Workflow Tools (11)
+            workflow_create: {
+                name: 'workflow_create',
+                description: 'Create custom workflows',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string'
+                        },
+                        steps: {
+                            type: 'array'
+                        },
+                        triggers: {
+                            type: 'array'
+                        }
+                    },
+                    required: [
+                        'name',
+                        'steps'
+                    ]
+                }
+            },
+            sparc_mode: {
+                name: 'sparc_mode',
+                description: 'Run SPARC development modes',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        mode: {
+                            type: 'string',
+                            enum: [
+                                'dev',
+                                'api',
+                                'ui',
+                                'test',
+                                'refactor'
+                            ]
+                        },
+                        task_description: {
+                            type: 'string'
+                        },
+                        options: {
+                            type: 'object'
+                        }
+                    },
+                    required: [
+                        'mode',
+                        'task_description'
+                    ]
+                }
+            },
+            // Additional Swarm Tools
+            agent_list: {
+                name: 'agent_list',
+                description: 'List active agents & capabilities',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            agent_metrics: {
+                name: 'agent_metrics',
+                description: 'Agent performance metrics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        agentId: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            swarm_monitor: {
+                name: 'swarm_monitor',
+                description: 'Real-time swarm monitoring',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        },
+                        interval: {
+                            type: 'number'
+                        }
+                    }
+                }
+            },
+            topology_optimize: {
+                name: 'topology_optimize',
+                description: 'Auto-optimize swarm topology',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            load_balance: {
+                name: 'load_balance',
+                description: 'Distribute tasks efficiently',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        },
+                        tasks: {
+                            type: 'array'
+                        }
+                    }
+                }
+            },
+            coordination_sync: {
+                name: 'coordination_sync',
+                description: 'Sync agent coordination',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            swarm_scale: {
+                name: 'swarm_scale',
+                description: 'Auto-scale agent count',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        },
+                        targetSize: {
+                            type: 'number'
+                        }
+                    }
+                }
+            },
+            swarm_destroy: {
+                name: 'swarm_destroy',
+                description: 'Gracefully shutdown swarm',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        swarmId: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'swarmId'
+                    ]
+                }
+            },
+            // Additional Neural Tools - DEPRECATED: Removed 13 advanced neural tools
+            // Tools removed: neural_predict, model_load, model_save, wasm_optimize, inference_run,
+            // pattern_recognize, cognitive_analyze, learning_adapt, neural_compress, ensemble_create,
+            // transfer_learn, neural_explain
+            // Rationale: Complexity reduction for novice users, functionality available via plugins
+            // Additional Memory Tools - DEPRECATED: Removed 10 advanced memory management tools
+            // Tools removed: memory_persist, memory_namespace, memory_backup, memory_restore,
+            // memory_compress, memory_sync, cache_manage, state_snapshot, context_restore, memory_analytics
+            // Retained: memory_usage, memory_search (core functionality)
+            // Rationale: Simplified memory interface, basic features in memory_usage sufficient
+            // Additional Analysis Tools
+            task_status: {
+                name: 'task_status',
+                description: 'Check task execution status',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        taskId: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'taskId'
+                    ]
+                }
+            },
+            task_results: {
+                name: 'task_results',
+                description: 'Get task completion results',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        taskId: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'taskId'
+                    ]
+                }
+            },
+            benchmark_run: {
+                name: 'benchmark_run',
+                description: 'Performance benchmarks',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        suite: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            metrics_collect: {
+                name: 'metrics_collect',
+                description: 'Collect system metrics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        components: {
+                            type: 'array'
+                        }
+                    }
+                }
+            },
+            trend_analysis: {
+                name: 'trend_analysis',
+                description: 'Analyze performance trends',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        metric: {
+                            type: 'string'
+                        },
+                        period: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'metric'
+                    ]
+                }
             },
-          ],
-        },
-      };
-    } catch (error) {
-      return this.createErrorResponse(id, -32000, 'Resource read failed', error.message);
+            cost_analysis: {
+                name: 'cost_analysis',
+                description: 'Cost and resource analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        timeframe: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            quality_assess: {
+                name: 'quality_assess',
+                description: 'Quality assessment',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        target: {
+                            type: 'string'
+                        },
+                        criteria: {
+                            type: 'array'
+                        }
+                    },
+                    required: [
+                        'target'
+                    ]
+                }
+            },
+            error_analysis: {
+                name: 'error_analysis',
+                description: 'Error pattern analysis',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        logs: {
+                            type: 'array'
+                        }
+                    }
+                }
+            },
+            usage_stats: {
+                name: 'usage_stats',
+                description: 'Usage statistics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        component: {
+                            type: 'string'
+                        }
+                    }
+                }
+            },
+            health_check: {
+                name: 'health_check',
+                description: 'System health monitoring',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        components: {
+                            type: 'array'
+                        }
+                    }
+                }
+            },
+            // Additional Workflow Tools - DEPRECATED: Removed 9 workflow automation tools
+            // Tools removed: workflow_execute, workflow_export, automation_setup, pipeline_create,
+            // scheduler_manage, trigger_setup, workflow_template, batch_process, parallel_execute
+            // Retained: workflow_create (basic functionality)
+            // Rationale: Workflow execution integrated into task_orchestrate, reduces tool count
+            // GitHub Integration Tools
+            github_issue_track: {
+                name: 'github_issue_track',
+                description: 'Issue tracking & triage',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        action: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'repo',
+                        'action'
+                    ]
+                }
+            },
+            github_release_coord: {
+                name: 'github_release_coord',
+                description: 'Release coordination',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        version: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'repo',
+                        'version'
+                    ]
+                }
+            },
+            github_workflow_auto: {
+                name: 'github_workflow_auto',
+                description: 'Workflow automation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        workflow: {
+                            type: 'object'
+                        }
+                    },
+                    required: [
+                        'repo',
+                        'workflow'
+                    ]
+                }
+            },
+            github_code_review: {
+                name: 'github_code_review',
+                description: 'Automated code review',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        },
+                        pr: {
+                            type: 'number'
+                        }
+                    },
+                    required: [
+                        'repo',
+                        'pr'
+                    ]
+                }
+            },
+            github_sync_coord: {
+                name: 'github_sync_coord',
+                description: 'Multi-repo sync coordination',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repos: {
+                            type: 'array'
+                        }
+                    },
+                    required: [
+                        'repos'
+                    ]
+                }
+            },
+            github_metrics: {
+                name: 'github_metrics',
+                description: 'Repository metrics',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        repo: {
+                            type: 'string'
+                        }
+                    },
+                    required: [
+                        'repo'
+                    ]
+                }
+            }
+        };
     }
-  }
-
-  async executeTool(name, args) {
-    // Simulate tool execution based on the tool name
-    switch (name) {
-      case 'swarm_init':
-        const swarmId = `swarm_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-        // Track swarm creation
-        if (global.agentTracker) {
-          global.agentTracker.trackSwarm(swarmId, {
-            topology: args.topology || 'mesh',
-            maxAgents: args.maxAgents || 5,
-            strategy: args.strategy || 'balanced',
-          });
-        }
-
-        const swarmData = {
-          id: swarmId,
-          name: `Swarm-${new Date().toISOString().split('T')[0]}`,
-          topology: args.topology || 'hierarchical',
-          queenMode: 'collaborative',
-          maxAgents: args.maxAgents || 8,
-          consensusThreshold: 0.7,
-          memoryTTL: 86400, // 24 hours
-          config: JSON.stringify({
-            strategy: args.strategy || 'auto',
-            sessionId: this.sessionId,
-            createdBy: 'mcp-server',
-          }),
+    initializeResources() {
+        return {
+            'claude-flow://swarms': {
+                uri: 'claude-flow://swarms',
+                name: 'Active Swarms',
+                description: 'List of active swarm configurations and status',
+                mimeType: 'application/json'
+            },
+            'claude-flow://agents': {
+                uri: 'claude-flow://agents',
+                name: 'Agent Registry',
+                description: 'Registry of available agents and their capabilities',
+                mimeType: 'application/json'
+            },
+            'claude-flow://models': {
+                uri: 'claude-flow://models',
+                name: 'Neural Models',
+                description: 'Available neural network models and training status',
+                mimeType: 'application/json'
+            },
+            'claude-flow://performance': {
+                uri: 'claude-flow://performance',
+                name: 'Performance Metrics',
+                description: 'Real-time performance metrics and benchmarks',
+                mimeType: 'application/json'
+            }
         };
-
-        // Store swarm data in memory store (same as npx commands)
+    }
+    async handleMessage(message) {
         try {
-          await this.memoryStore.store(`swarm:${swarmId}`, JSON.stringify(swarmData), {
-            namespace: 'swarms',
-            metadata: { type: 'swarm_data', sessionId: this.sessionId },
-          });
-          await this.memoryStore.store('active_swarm', swarmId, {
-            namespace: 'system',
-            metadata: { type: 'active_swarm', sessionId: this.sessionId },
-          });
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Swarm persisted to memory: ${swarmId}`,
-          );
+            const { id, method, params } = message;
+            switch(method){
+                case 'initialize':
+                    return this.handleInitialize(id, params);
+                case 'tools/list':
+                    return this.handleToolsList(id);
+                case 'tools/call':
+                    return this.handleToolCall(id, params);
+                case 'resources/list':
+                    return this.handleResourcesList(id);
+                case 'resources/read':
+                    return this.handleResourceRead(id, params);
+                default:
+                    return this.createErrorResponse(id, -32601, 'Method not found');
+            }
         } catch (error) {
-          console.error(
-            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist swarm:`,
-            error,
-          );
+            return this.createErrorResponse(message.id, -32603, 'Internal error', error.message);
         }
-
+    }
+    handleInitialize(id, params) {
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) 🔌 Connection established: ${this.sessionId}`);
         return {
-          success: true,
-          swarmId: swarmId,
-          topology: swarmData.topology,
-          maxAgents: swarmData.maxAgents,
-          strategy: args.strategy || 'auto',
-          status: 'initialized',
-          persisted: !!this.databaseManager,
-          timestamp: new Date().toISOString(),
+            jsonrpc: '2.0',
+            id,
+            result: {
+                protocolVersion: '2024-11-05',
+                capabilities: this.capabilities,
+                serverInfo: {
+                    name: 'claude-flow',
+                    version: this.version
+                }
+            }
         };
-
-      case 'agent_spawn':
-        const agentId = `agent_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
-        const resolvedType = resolveLegacyAgentType(args.type);
-        const agentData = {
-          id: agentId,
-          swarmId: args.swarmId || (await this.getActiveSwarmId()),
-          name: args.name || `${resolvedType}-${Date.now()}`,
-          type: resolvedType,
-          status: 'active',
-          capabilities: JSON.stringify(args.capabilities || []),
-          metadata: JSON.stringify({
-            sessionId: this.sessionId,
-            createdBy: 'mcp-server',
-            spawnedAt: new Date().toISOString(),
-          }),
+    }
+    handleToolsList(id) {
+        const toolsList = Object.values(this.tools);
+        return {
+            jsonrpc: '2.0',
+            id,
+            result: {
+                tools: toolsList
+            }
         };
-
-        // Store agent data in memory store (same as npx commands)
+    }
+    async handleToolCall(id, params) {
+        const { name, arguments: args } = params;
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) 🔧 Tool called: ${name}`);
         try {
-          const swarmId = agentData.swarmId || (await this.getActiveSwarmId());
-          if (swarmId) {
-            await this.memoryStore.store(`agent:${swarmId}:${agentId}`, JSON.stringify(agentData), {
-              namespace: 'agents',
-              metadata: { type: 'agent_data', swarmId: swarmId, sessionId: this.sessionId },
-            });
-          } else {
-            // Fallback to old format if no swarm ID
-            await this.memoryStore.store(`agent:${agentId}`, JSON.stringify(agentData), {
-              namespace: 'agents',
-              metadata: { type: 'agent_data', sessionId: this.sessionId },
-            });
-          }
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Agent persisted to memory: ${agentId}`,
-          );
+            const result = await this.executeTool(name, args);
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2)
+                        }
+                    ]
+                }
+            };
         } catch (error) {
-          console.error(
-            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist agent:`,
-            error,
-          );
+            return this.createErrorResponse(id, -32000, 'Tool execution failed', error.message);
         }
-
-        // Track spawned agent
-        if (global.agentTracker) {
-          global.agentTracker.trackAgent(agentId, {
-            ...agentData,
-            capabilities: args.capabilities || [],
-          });
-        }
-
-        return {
-          success: true,
-          agentId: agentId,
-          type: args.type,
-          name: agentData.name,
-          status: 'active',
-          capabilities: args.capabilities || [],
-          persisted: !!this.databaseManager,
-          timestamp: new Date().toISOString(),
-        };
-
-      case 'neural_train':
-        const epochs = args.epochs || 50;
-        const baseAccuracy = 0.65;
-        const maxAccuracy = 0.98;
-
-        // Realistic training progression: more epochs = better accuracy but with diminishing returns
-        const epochFactor = Math.min(epochs / 100, 10); // Normalize epochs
-        const accuracyGain = (maxAccuracy - baseAccuracy) * (1 - Math.exp(-epochFactor / 3));
-        const finalAccuracy = baseAccuracy + accuracyGain + (Math.random() * 0.05 - 0.025); // Add some noise
-
-        // Training time increases with epochs but not linearly (parallel processing)
-        const baseTime = 2;
-        const timePerEpoch = 0.08;
-        const trainingTime = baseTime + epochs * timePerEpoch + (Math.random() * 2 - 1);
-
-        return {
-          success: true,
-          modelId: `model_${args.pattern_type || 'general'}_${Date.now()}`,
-          pattern_type: args.pattern_type || 'coordination',
-          epochs: epochs,
-          accuracy: Math.min(finalAccuracy, maxAccuracy),
-          training_time: Math.max(trainingTime, 1),
-          status: 'completed',
-          improvement_rate: epochFactor > 1 ? 'converged' : 'improving',
-          data_source: args.training_data || 'recent',
-          timestamp: new Date().toISOString(),
-        };
-
-      case 'memory_usage':
-        return await this.handleMemoryUsage(args);
-
-      case 'performance_report':
+    }
+    handleResourcesList(id) {
+        const resourcesList = Object.values(this.resources);
         return {
-          success: true,
-          timeframe: args.timeframe || '24h',
-          format: args.format || 'summary',
-          metrics: {
-            tasks_executed: Math.floor(Math.random() * 200) + 50,
-            success_rate: Math.random() * 0.2 + 0.8,
-            avg_execution_time: Math.random() * 10 + 5,
-            agents_spawned: Math.floor(Math.random() * 50) + 10,
-            memory_efficiency: Math.random() * 0.3 + 0.7,
-            neural_events: Math.floor(Math.random() * 100) + 20,
-          },
-          timestamp: new Date().toISOString(),
+            jsonrpc: '2.0',
+            id,
+            result: {
+                resources: resourcesList
+            }
         };
-
-      // DEPRECATED: Enhanced Neural Tools - Handlers removed for 10 deprecated neural tools
-      // Removed cases: model_save, model_load, neural_predict, pattern_recognize, cognitive_analyze,
-      // learning_adapt, neural_compress, ensemble_create, transfer_learn, neural_explain
-      // Rationale: Complexity reduction, functionality available via plugin architecture
-
-      case 'agent_list':
-        // First check agent tracker for real-time data
-        if (global.agentTracker) {
-          const swarmId = args.swarmId || (await this.getActiveSwarmId());
-          const trackedAgents = global.agentTracker.getAgents(swarmId);
-
-          if (trackedAgents.length > 0) {
+    }
+    async handleResourceRead(id, params) {
+        const { uri } = params;
+        try {
+            const content = await this.readResource(uri);
             return {
-              success: true,
-              swarmId: swarmId || 'dynamic',
-              agents: trackedAgents,
-              count: trackedAgents.length,
-              timestamp: new Date().toISOString(),
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    contents: [
+                        {
+                            uri,
+                            mimeType: 'application/json',
+                            text: JSON.stringify(content, null, 2)
+                        }
+                    ]
+                }
             };
-          }
+        } catch (error) {
+            return this.createErrorResponse(id, -32000, 'Resource read failed', error.message);
         }
-
-        if (this.databaseManager) {
-          try {
-            const swarmId = args.swarmId || (await this.getActiveSwarmId());
-            if (!swarmId) {
-              return {
+    }
+    async executeTool(name, args) {
+        // Simulate tool execution based on the tool name
+        switch(name){
+            case 'swarm_init':
+                const swarmId = `swarm_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                // Track swarm creation
+                if (global.agentTracker) {
+                    global.agentTracker.trackSwarm(swarmId, {
+                        topology: args.topology || 'mesh',
+                        maxAgents: args.maxAgents || 5,
+                        strategy: args.strategy || 'balanced'
+                    });
+                }
+                const swarmData = {
+                    id: swarmId,
+                    name: `Swarm-${new Date().toISOString().split('T')[0]}`,
+                    topology: args.topology || 'hierarchical',
+                    queenMode: 'collaborative',
+                    maxAgents: args.maxAgents || 8,
+                    consensusThreshold: 0.7,
+                    memoryTTL: 86400,
+                    config: JSON.stringify({
+                        strategy: args.strategy || 'auto',
+                        sessionId: this.sessionId,
+                        createdBy: 'mcp-server'
+                    })
+                };
+                // Store swarm data in memory store (same as npx commands)
+                try {
+                    await this.memoryStore.store(`swarm:${swarmId}`, JSON.stringify(swarmData), {
+                        namespace: 'swarms',
+                        metadata: {
+                            type: 'swarm_data',
+                            sessionId: this.sessionId
+                        }
+                    });
+                    await this.memoryStore.store('active_swarm', swarmId, {
+                        namespace: 'system',
+                        metadata: {
+                            type: 'active_swarm',
+                            sessionId: this.sessionId
+                        }
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Swarm persisted to memory: ${swarmId}`);
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist swarm:`, error);
+                }
+                return {
+                    success: true,
+                    swarmId: swarmId,
+                    topology: swarmData.topology,
+                    maxAgents: swarmData.maxAgents,
+                    strategy: args.strategy || 'auto',
+                    status: 'initialized',
+                    persisted: !!this.databaseManager,
+                    timestamp: new Date().toISOString()
+                };
+            case 'agent_spawn':
+                const agentId = `agent_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`;
+                const resolvedType = resolveLegacyAgentType(args.type);
+                const agentData = {
+                    id: agentId,
+                    swarmId: args.swarmId || await this.getActiveSwarmId(),
+                    name: args.name || `${resolvedType}-${Date.now()}`,
+                    type: resolvedType,
+                    status: 'active',
+                    capabilities: JSON.stringify(args.capabilities || []),
+                    metadata: JSON.stringify({
+                        sessionId: this.sessionId,
+                        createdBy: 'mcp-server',
+                        spawnedAt: new Date().toISOString()
+                    })
+                };
+                // Store agent data in memory store (same as npx commands)
+                try {
+                    const swarmId = agentData.swarmId || await this.getActiveSwarmId();
+                    if (swarmId) {
+                        await this.memoryStore.store(`agent:${swarmId}:${agentId}`, JSON.stringify(agentData), {
+                            namespace: 'agents',
+                            metadata: {
+                                type: 'agent_data',
+                                swarmId: swarmId,
+                                sessionId: this.sessionId
+                            }
+                        });
+                    } else {
+                        // Fallback to old format if no swarm ID
+                        await this.memoryStore.store(`agent:${agentId}`, JSON.stringify(agentData), {
+                            namespace: 'agents',
+                            metadata: {
+                                type: 'agent_data',
+                                sessionId: this.sessionId
+                            }
+                        });
+                    }
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Agent persisted to memory: ${agentId}`);
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist agent:`, error);
+                }
+                // Track spawned agent
+                if (global.agentTracker) {
+                    global.agentTracker.trackAgent(agentId, {
+                        ...agentData,
+                        capabilities: args.capabilities || []
+                    });
+                }
+                return {
+                    success: true,
+                    agentId: agentId,
+                    type: args.type,
+                    name: agentData.name,
+                    status: 'active',
+                    capabilities: args.capabilities || [],
+                    persisted: !!this.databaseManager,
+                    timestamp: new Date().toISOString()
+                };
+            case 'neural_train':
+                const epochs = args.epochs || 50;
+                const baseAccuracy = 0.65;
+                const maxAccuracy = 0.98;
+                // Realistic training progression: more epochs = better accuracy but with diminishing returns
+                const epochFactor = Math.min(epochs / 100, 10); // Normalize epochs
+                const accuracyGain = (maxAccuracy - baseAccuracy) * (1 - Math.exp(-epochFactor / 3));
+                const finalAccuracy = baseAccuracy + accuracyGain + (Math.random() * 0.05 - 0.025); // Add some noise
+                // Training time increases with epochs but not linearly (parallel processing)
+                const baseTime = 2;
+                const timePerEpoch = 0.08;
+                const trainingTime = baseTime + epochs * timePerEpoch + (Math.random() * 2 - 1);
+                return {
+                    success: true,
+                    modelId: `model_${args.pattern_type || 'general'}_${Date.now()}`,
+                    pattern_type: args.pattern_type || 'coordination',
+                    epochs: epochs,
+                    accuracy: Math.min(finalAccuracy, maxAccuracy),
+                    training_time: Math.max(trainingTime, 1),
+                    status: 'completed',
+                    improvement_rate: epochFactor > 1 ? 'converged' : 'improving',
+                    data_source: args.training_data || 'recent',
+                    timestamp: new Date().toISOString()
+                };
+            case 'memory_usage':
+                return await this.handleMemoryUsage(args);
+            case 'performance_report':
+                return {
+                    success: true,
+                    timeframe: args.timeframe || '24h',
+                    format: args.format || 'summary',
+                    metrics: {
+                        tasks_executed: Math.floor(Math.random() * 200) + 50,
+                        success_rate: Math.random() * 0.2 + 0.8,
+                        avg_execution_time: Math.random() * 10 + 5,
+                        agents_spawned: Math.floor(Math.random() * 50) + 10,
+                        memory_efficiency: Math.random() * 0.3 + 0.7,
+                        neural_events: Math.floor(Math.random() * 100) + 20
+                    },
+                    timestamp: new Date().toISOString()
+                };
+            // DEPRECATED: Enhanced Neural Tools - Handlers removed for 10 deprecated neural tools
+            // Removed cases: model_save, model_load, neural_predict, pattern_recognize, cognitive_analyze,
+            // learning_adapt, neural_compress, ensemble_create, transfer_learn, neural_explain
+            // Rationale: Complexity reduction, functionality available via plugin architecture
+            case 'agent_list':
+                // First check agent tracker for real-time data
+                if (global.agentTracker) {
+                    const swarmId = args.swarmId || await this.getActiveSwarmId();
+                    const trackedAgents = global.agentTracker.getAgents(swarmId);
+                    if (trackedAgents.length > 0) {
+                        return {
+                            success: true,
+                            swarmId: swarmId || 'dynamic',
+                            agents: trackedAgents,
+                            count: trackedAgents.length,
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                }
+                if (this.databaseManager) {
+                    try {
+                        const swarmId = args.swarmId || await this.getActiveSwarmId();
+                        if (!swarmId) {
+                            return {
+                                success: false,
+                                error: 'No active swarm found',
+                                agents: [],
+                                timestamp: new Date().toISOString()
+                            };
+                        }
+                        const agents = await this.databaseManager.getAgents(swarmId);
+                        return {
+                            success: true,
+                            swarmId: swarmId,
+                            agents: agents.map((agent)=>({
+                                    id: agent.id,
+                                    name: agent.name,
+                                    type: agent.type,
+                                    status: agent.status,
+                                    capabilities: JSON.parse(agent.capabilities || '[]'),
+                                    created: agent.created_at,
+                                    lastActive: agent.last_active_at
+                                })),
+                            count: agents.length,
+                            timestamp: new Date().toISOString()
+                        };
+                    } catch (error) {
+                        console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to list agents:`, error);
+                        return {
+                            success: false,
+                            error: error.message,
+                            agents: [],
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                }
+                // Fallback mock response
+                return {
+                    success: true,
+                    swarmId: args.swarmId || 'mock-swarm',
+                    agents: [
+                        {
+                            id: 'agent-1',
+                            name: 'coordinator-1',
+                            type: 'coordinator',
+                            status: 'active',
+                            capabilities: []
+                        },
+                        {
+                            id: 'agent-2',
+                            name: 'researcher-1',
+                            type: 'researcher',
+                            status: 'active',
+                            capabilities: []
+                        },
+                        {
+                            id: 'agent-3',
+                            name: 'coder-1',
+                            type: 'coder',
+                            status: 'busy',
+                            capabilities: []
+                        }
+                    ],
+                    count: 3,
+                    timestamp: new Date().toISOString()
+                };
+            case 'swarm_status':
+                try {
+                    // Get active swarm ID from memory store
+                    let swarmId = args.swarmId;
+                    if (!swarmId) {
+                        swarmId = await this.memoryStore.retrieve('active_swarm', {
+                            namespace: 'system'
+                        });
+                    }
+                    if (!swarmId) {
+                        return {
+                            success: false,
+                            error: 'No active swarm found',
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                    // Check agent tracker for real counts
+                    if (global.agentTracker) {
+                        const status = global.agentTracker.getSwarmStatus(swarmId);
+                        if (status.agentCount > 0) {
+                            const swarmDataRaw = await this.memoryStore.retrieve(`swarm:${swarmId}`, {
+                                namespace: 'swarms'
+                            });
+                            const swarm = swarmDataRaw ? typeof swarmDataRaw === 'string' ? JSON.parse(swarmDataRaw) : swarmDataRaw : {};
+                            return {
+                                success: true,
+                                swarmId: swarmId,
+                                topology: swarm.topology || 'mesh',
+                                agentCount: status.agentCount,
+                                activeAgents: status.activeAgents,
+                                taskCount: status.taskCount,
+                                pendingTasks: status.pendingTasks,
+                                completedTasks: status.completedTasks,
+                                timestamp: new Date().toISOString()
+                            };
+                        }
+                    }
+                    // Retrieve swarm data from memory store
+                    const swarmDataRaw = await this.memoryStore.retrieve(`swarm:${swarmId}`, {
+                        namespace: 'swarms'
+                    });
+                    if (!swarmDataRaw) {
+                        return {
+                            success: false,
+                            error: `Swarm ${swarmId} not found`,
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                    const swarm = typeof swarmDataRaw === 'string' ? JSON.parse(swarmDataRaw) : swarmDataRaw;
+                    // Retrieve agents from memory
+                    const agentsData = await this.memoryStore.list({
+                        namespace: 'agents',
+                        limit: 100
+                    });
+                    // Filter agents for this swarm
+                    const swarmAgents = agentsData.filter((entry)=>entry.key.startsWith(`agent:${swarmId}:`)).map((entry)=>{
+                        try {
+                            return JSON.parse(entry.value);
+                        } catch (e) {
+                            return null;
+                        }
+                    }).filter((agent)=>agent !== null);
+                    // Retrieve tasks from memory
+                    const tasksData = await this.memoryStore.list({
+                        namespace: 'tasks',
+                        limit: 100
+                    });
+                    // Filter tasks for this swarm
+                    const swarmTasks = tasksData.filter((entry)=>entry.key.startsWith(`task:${swarmId}:`)).map((entry)=>{
+                        try {
+                            return JSON.parse(entry.value);
+                        } catch (e) {
+                            return null;
+                        }
+                    }).filter((task)=>task !== null);
+                    // Calculate stats
+                    const activeAgents = swarmAgents.filter((a)=>a.status === 'active' || a.status === 'busy').length;
+                    const pendingTasks = swarmTasks.filter((t)=>t.status === 'pending').length;
+                    const completedTasks = swarmTasks.filter((t)=>t.status === 'completed').length;
+                    const response = {
+                        success: true,
+                        swarmId: swarmId,
+                        topology: swarm.topology || 'hierarchical',
+                        agentCount: swarmAgents.length,
+                        activeAgents: activeAgents,
+                        taskCount: swarmTasks.length,
+                        pendingTasks: pendingTasks,
+                        completedTasks: completedTasks,
+                        timestamp: new Date().toISOString()
+                    };
+                    // Add verbose details if requested
+                    if (args.verbose === true || args.verbose === 'true') {
+                        response.agents = swarmAgents;
+                        response.tasks = swarmTasks;
+                        response.swarmDetails = swarm;
+                    }
+                    return response;
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to get swarm status:`, error);
+                    // Return a more informative fallback response
+                    return {
+                        success: false,
+                        error: error.message || 'Failed to retrieve swarm status',
+                        swarmId: args.swarmId || 'unknown',
+                        topology: 'unknown',
+                        agentCount: 0,
+                        activeAgents: 0,
+                        taskCount: 0,
+                        pendingTasks: 0,
+                        completedTasks: 0,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+            case 'task_orchestrate':
+                const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                // Track task creation
+                if (global.agentTracker) {
+                    global.agentTracker.trackTask(taskId, {
+                        task: args.task,
+                        strategy: args.strategy || 'parallel',
+                        priority: args.priority || 'medium',
+                        status: 'pending',
+                        swarmId: args.swarmId
+                    });
+                }
+                const swarmIdForTask = args.swarmId || await this.getActiveSwarmId();
+                const taskData = {
+                    id: taskId,
+                    swarmId: swarmIdForTask,
+                    description: args.task,
+                    priority: args.priority || 'medium',
+                    strategy: args.strategy || 'auto',
+                    status: 'pending',
+                    dependencies: JSON.stringify(args.dependencies || []),
+                    assignedAgents: JSON.stringify([]),
+                    requireConsensus: false,
+                    maxAgents: 5,
+                    requiredCapabilities: JSON.stringify([]),
+                    metadata: JSON.stringify({
+                        sessionId: this.sessionId,
+                        createdBy: 'mcp-server',
+                        orchestratedAt: new Date().toISOString()
+                    })
+                };
+                // Store task data in memory store
+                try {
+                    if (swarmIdForTask) {
+                        await this.memoryStore.store(`task:${swarmIdForTask}:${taskId}`, JSON.stringify(taskData), {
+                            namespace: 'tasks',
+                            metadata: {
+                                type: 'task_data',
+                                swarmId: swarmIdForTask,
+                                sessionId: this.sessionId
+                            }
+                        });
+                        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Task persisted to memory: ${taskId}`);
+                    }
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist task:`, error);
+                }
+                return {
+                    success: true,
+                    taskId: taskId,
+                    task: args.task,
+                    strategy: taskData.strategy,
+                    priority: taskData.priority,
+                    status: 'pending',
+                    persisted: true,
+                    timestamp: new Date().toISOString()
+                };
+            // DEPRECATED: DAA Tools Implementation - Handlers removed for 6 deprecated DAA tools
+            // Removed cases: daa_agent_create, daa_capability_match, daa_resource_alloc,
+            // daa_lifecycle_manage, daa_communication, daa_consensus
+            // Rationale: DAA functionality consolidated into core swarm tools
+            // Note: DAA implementation files (daa-tools.js) retained for backward compatibility
+            // Workflow Tools Implementation
+            case 'workflow_create':
+                if (global.workflowManager) {
+                    return global.workflowManager.workflow_create(args);
+                }
+                return {
+                    success: false,
+                    error: 'Workflow manager not initialized',
+                    timestamp: new Date().toISOString()
+                };
+            // DEPRECATED: Workflow Execution Tools - Handlers removed for 5 deprecated workflow tools
+            // Removed cases: workflow_execute, parallel_execute, batch_process, workflow_export, workflow_template
+            // Retained: workflow_create (basic functionality)
+            // Rationale: Workflow execution integrated into task_orchestrate
+            // Note: Workflow implementation files (workflow-tools.js) retained for backward compatibility
+            // Performance Tools Implementation
+            case 'performance_report':
+                if (global.performanceMonitor) {
+                    return global.performanceMonitor.performance_report(args);
+                }
+                return {
+                    success: false,
+                    error: 'Performance monitor not initialized',
+                    timestamp: new Date().toISOString()
+                };
+            case 'bottleneck_analyze':
+                if (global.performanceMonitor) {
+                    return global.performanceMonitor.bottleneck_analyze(args);
+                }
+                return {
+                    success: false,
+                    error: 'Performance monitor not initialized',
+                    timestamp: new Date().toISOString()
+                };
+            case 'memory_analytics':
+                if (global.performanceMonitor) {
+                    return global.performanceMonitor.memory_analytics(args);
+                }
+                return {
+                    success: false,
+                    error: 'Performance monitor not initialized',
+                    timestamp: new Date().toISOString()
+                };
+            default:
+                return {
+                    success: true,
+                    tool: name,
+                    message: `Tool ${name} executed successfully`,
+                    args: args,
+                    timestamp: new Date().toISOString()
+                };
+        }
+    }
+    async readResource(uri) {
+        switch(uri){
+            case 'claude-flow://swarms':
+                return {
+                    active_swarms: 3,
+                    total_agents: 15,
+                    topologies: [
+                        'hierarchical',
+                        'mesh',
+                        'ring',
+                        'star'
+                    ],
+                    performance: '2.8-4.4x speedup'
+                };
+            case 'claude-flow://agents':
+                return {
+                    total_agents: 8,
+                    types: [
+                        'researcher',
+                        'coder',
+                        'analyst',
+                        'architect',
+                        'tester',
+                        'coordinator',
+                        'reviewer',
+                        'optimizer'
+                    ],
+                    active: 15,
+                    capabilities: 127
+                };
+            case 'claude-flow://models':
+                return {
+                    total_models: 27,
+                    wasm_enabled: true,
+                    simd_support: true,
+                    training_active: true,
+                    accuracy_avg: 0.89
+                };
+            case 'claude-flow://performance':
+                return {
+                    uptime: '99.9%',
+                    token_reduction: '32.3%',
+                    swe_bench_rate: '84.8%',
+                    speed_improvement: '2.8-4.4x',
+                    memory_efficiency: '78%'
+                };
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    }
+    async handleMemoryUsage(args) {
+        if (!this.memoryStore) {
+            return {
                 success: false,
-                error: 'No active swarm found',
-                agents: [],
-                timestamp: new Date().toISOString(),
-              };
+                error: 'Shared memory system not initialized',
+                timestamp: new Date().toISOString()
+            };
+        }
+        try {
+            switch(args.action){
+                case 'store':
+                    const storeResult = await this.memoryStore.store(args.key, args.value, {
+                        namespace: args.namespace || 'default',
+                        ttl: args.ttl,
+                        metadata: {
+                            sessionId: this.sessionId,
+                            storedBy: 'mcp-server',
+                            type: 'knowledge'
+                        }
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Stored in shared memory: ${args.key} (namespace: ${args.namespace || 'default'})`);
+                    return {
+                        success: true,
+                        action: 'store',
+                        key: args.key,
+                        namespace: args.namespace || 'default',
+                        stored: true,
+                        size: storeResult.size || args.value.length,
+                        id: storeResult.id,
+                        storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
+                        timestamp: new Date().toISOString()
+                    };
+                case 'retrieve':
+                    const value = await this.memoryStore.retrieve(args.key, {
+                        namespace: args.namespace || 'default'
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Retrieved from shared memory: ${args.key} (found: ${value !== null})`);
+                    return {
+                        success: true,
+                        action: 'retrieve',
+                        key: args.key,
+                        value: value,
+                        found: value !== null,
+                        namespace: args.namespace || 'default',
+                        storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
+                        timestamp: new Date().toISOString()
+                    };
+                case 'list':
+                    const entries = await this.memoryStore.list({
+                        namespace: args.namespace || 'default',
+                        limit: 100
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Listed shared memory entries: ${entries.length} (namespace: ${args.namespace || 'default'})`);
+                    return {
+                        success: true,
+                        action: 'list',
+                        namespace: args.namespace || 'default',
+                        entries: entries,
+                        count: entries.length,
+                        storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
+                        timestamp: new Date().toISOString()
+                    };
+                case 'delete':
+                    const deleted = await this.memoryStore.delete(args.key, {
+                        namespace: args.namespace || 'default'
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Deleted from shared memory: ${args.key} (success: ${deleted})`);
+                    return {
+                        success: true,
+                        action: 'delete',
+                        key: args.key,
+                        namespace: args.namespace || 'default',
+                        deleted: deleted,
+                        storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
+                        timestamp: new Date().toISOString()
+                    };
+                case 'search':
+                    const results = await this.memoryStore.search(args.value || '', {
+                        namespace: args.namespace || 'default',
+                        limit: 50
+                    });
+                    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] Searched shared memory: ${results.length} results for "${args.value}"`);
+                    return {
+                        success: true,
+                        action: 'search',
+                        pattern: args.value,
+                        namespace: args.namespace || 'default',
+                        results: results,
+                        count: results.length,
+                        storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
+                        timestamp: new Date().toISOString()
+                    };
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown memory action: ${args.action}`,
+                        timestamp: new Date().toISOString()
+                    };
             }
-
-            const agents = await this.databaseManager.getAgents(swarmId);
+        } catch (error) {
+            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Shared memory operation failed:`, error);
             return {
-              success: true,
-              swarmId: swarmId,
-              agents: agents.map((agent) => ({
-                id: agent.id,
-                name: agent.name,
-                type: agent.type,
-                status: agent.status,
-                capabilities: JSON.parse(agent.capabilities || '[]'),
-                created: agent.created_at,
-                lastActive: agent.last_active_at,
-              })),
-              count: agents.length,
-              timestamp: new Date().toISOString(),
+                success: false,
+                error: error.message,
+                action: args.action,
+                storage_type: this.memoryStore?.isUsingFallback() ? 'in-memory' : 'sqlite',
+                timestamp: new Date().toISOString()
             };
-          } catch (error) {
-            console.error(
-              `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to list agents:`,
-              error,
-            );
+        }
+    }
+    async handleMemorySearch(args) {
+        if (!this.memoryStore) {
             return {
-              success: false,
-              error: error.message,
-              agents: [],
-              timestamp: new Date().toISOString(),
+                success: false,
+                error: 'Memory system not initialized',
+                timestamp: new Date().toISOString()
             };
-          }
         }
-
-        // Fallback mock response
-        return {
-          success: true,
-          swarmId: args.swarmId || 'mock-swarm',
-          agents: [
-            {
-              id: 'agent-1',
-              name: 'coordinator-1',
-              type: 'coordinator',
-              status: 'active',
-              capabilities: [],
-            },
-            {
-              id: 'agent-2',
-              name: 'researcher-1',
-              type: 'researcher',
-              status: 'active',
-              capabilities: [],
-            },
-            { id: 'agent-3', name: 'coder-1', type: 'coder', status: 'busy', capabilities: [] },
-          ],
-          count: 3,
-          timestamp: new Date().toISOString(),
-        };
-
-      case 'swarm_status':
         try {
-          // Get active swarm ID from memory store
-          let swarmId = args.swarmId;
-          if (!swarmId) {
-            swarmId = await this.memoryStore.retrieve('active_swarm', {
-              namespace: 'system',
+            const results = await this.sharedMemory.search(args.pattern, {
+                namespace: args.namespace || 'default',
+                limit: args.limit || 10
             });
-          }
-
-          if (!swarmId) {
             return {
-              success: false,
-              error: 'No active swarm found',
-              timestamp: new Date().toISOString(),
-            };
-          }
-
-          // Check agent tracker for real counts
-          if (global.agentTracker) {
-            const status = global.agentTracker.getSwarmStatus(swarmId);
-            if (status.agentCount > 0) {
-              const swarmDataRaw = await this.memoryStore.retrieve(`swarm:${swarmId}`, {
-                namespace: 'swarms',
-              });
-              const swarm = swarmDataRaw
-                ? typeof swarmDataRaw === 'string'
-                  ? JSON.parse(swarmDataRaw)
-                  : swarmDataRaw
-                : {};
-
-              return {
                 success: true,
-                swarmId: swarmId,
-                topology: swarm.topology || 'mesh',
-                agentCount: status.agentCount,
-                activeAgents: status.activeAgents,
-                taskCount: status.taskCount,
-                pendingTasks: status.pendingTasks,
-                completedTasks: status.completedTasks,
-                timestamp: new Date().toISOString(),
-              };
-            }
-          }
-
-          // Retrieve swarm data from memory store
-          const swarmDataRaw = await this.memoryStore.retrieve(`swarm:${swarmId}`, {
-            namespace: 'swarms',
-          });
-
-          if (!swarmDataRaw) {
-            return {
-              success: false,
-              error: `Swarm ${swarmId} not found`,
-              timestamp: new Date().toISOString(),
+                pattern: args.pattern,
+                namespace: args.namespace || 'default',
+                results: results,
+                count: results.length,
+                timestamp: new Date().toISOString()
             };
-          }
-
-          const swarm = typeof swarmDataRaw === 'string' ? JSON.parse(swarmDataRaw) : swarmDataRaw;
-
-          // Retrieve agents from memory
-          const agentsData = await this.memoryStore.list({
-            namespace: 'agents',
-            limit: 100,
-          });
-
-          // Filter agents for this swarm
-          const swarmAgents = agentsData
-            .filter((entry) => entry.key.startsWith(`agent:${swarmId}:`))
-            .map((entry) => {
-              try {
-                return JSON.parse(entry.value);
-              } catch (e) {
-                return null;
-              }
-            })
-            .filter((agent) => agent !== null);
-
-          // Retrieve tasks from memory
-          const tasksData = await this.memoryStore.list({
-            namespace: 'tasks',
-            limit: 100,
-          });
-
-          // Filter tasks for this swarm
-          const swarmTasks = tasksData
-            .filter((entry) => entry.key.startsWith(`task:${swarmId}:`))
-            .map((entry) => {
-              try {
-                return JSON.parse(entry.value);
-              } catch (e) {
-                return null;
-              }
-            })
-            .filter((task) => task !== null);
-
-          // Calculate stats
-          const activeAgents = swarmAgents.filter(
-            (a) => a.status === 'active' || a.status === 'busy',
-          ).length;
-          const pendingTasks = swarmTasks.filter((t) => t.status === 'pending').length;
-          const completedTasks = swarmTasks.filter((t) => t.status === 'completed').length;
-
-          const response = {
-            success: true,
-            swarmId: swarmId,
-            topology: swarm.topology || 'hierarchical',
-            agentCount: swarmAgents.length,
-            activeAgents: activeAgents,
-            taskCount: swarmTasks.length,
-            pendingTasks: pendingTasks,
-            completedTasks: completedTasks,
-            timestamp: new Date().toISOString(),
-          };
-
-          // Add verbose details if requested
-          if (args.verbose === true || args.verbose === 'true') {
-            response.agents = swarmAgents;
-            response.tasks = swarmTasks;
-            response.swarmDetails = swarm;
-          }
-
-          return response;
         } catch (error) {
-          console.error(
-            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to get swarm status:`,
-            error,
-          );
-
-          // Return a more informative fallback response
-          return {
-            success: false,
-            error: error.message || 'Failed to retrieve swarm status',
-            swarmId: args.swarmId || 'unknown',
-            topology: 'unknown',
-            agentCount: 0,
-            activeAgents: 0,
-            taskCount: 0,
-            pendingTasks: 0,
-            completedTasks: 0,
-            timestamp: new Date().toISOString(),
-          };
-        }
-
-      case 'task_orchestrate':
-        const taskId = `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-
-        // Track task creation
-        if (global.agentTracker) {
-          global.agentTracker.trackTask(taskId, {
-            task: args.task,
-            strategy: args.strategy || 'parallel',
-            priority: args.priority || 'medium',
-            status: 'pending',
-            swarmId: args.swarmId,
-          });
+            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Memory search failed:`, error);
+            return {
+                success: false,
+                error: error.message,
+                timestamp: new Date().toISOString()
+            };
         }
-        const swarmIdForTask = args.swarmId || (await this.getActiveSwarmId());
-        const taskData = {
-          id: taskId,
-          swarmId: swarmIdForTask,
-          description: args.task,
-          priority: args.priority || 'medium',
-          strategy: args.strategy || 'auto',
-          status: 'pending',
-          dependencies: JSON.stringify(args.dependencies || []),
-          assignedAgents: JSON.stringify([]),
-          requireConsensus: false,
-          maxAgents: 5,
-          requiredCapabilities: JSON.stringify([]),
-          metadata: JSON.stringify({
-            sessionId: this.sessionId,
-            createdBy: 'mcp-server',
-            orchestratedAt: new Date().toISOString(),
-          }),
-        };
-
-        // Store task data in memory store
+    }
+    async getActiveSwarmId() {
         try {
-          if (swarmIdForTask) {
-            await this.memoryStore.store(
-              `task:${swarmIdForTask}:${taskId}`,
-              JSON.stringify(taskData),
-              {
-                namespace: 'tasks',
-                metadata: { type: 'task_data', swarmId: swarmIdForTask, sessionId: this.sessionId },
-              },
-            );
-            console.error(
-              `[${new Date().toISOString()}] INFO [claude-flow-mcp] Task persisted to memory: ${taskId}`,
-            );
-          }
+            const activeSwarmId = await this.memoryStore.retrieve('active_swarm', {
+                namespace: 'system'
+            });
+            return activeSwarmId || null;
         } catch (error) {
-          console.error(
-            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist task:`,
-            error,
-          );
-        }
-
-        return {
-          success: true,
-          taskId: taskId,
-          task: args.task,
-          strategy: taskData.strategy,
-          priority: taskData.priority,
-          status: 'pending',
-          persisted: true,
-          timestamp: new Date().toISOString(),
-        };
-
-      // DEPRECATED: DAA Tools Implementation - Handlers removed for 6 deprecated DAA tools
-      // Removed cases: daa_agent_create, daa_capability_match, daa_resource_alloc,
-      // daa_lifecycle_manage, daa_communication, daa_consensus
-      // Rationale: DAA functionality consolidated into core swarm tools
-      // Note: DAA implementation files (daa-tools.js) retained for backward compatibility
-
-      // Workflow Tools Implementation
-      case 'workflow_create':
-        if (global.workflowManager) {
-          return global.workflowManager.workflow_create(args);
-        }
-        return {
-          success: false,
-          error: 'Workflow manager not initialized',
-          timestamp: new Date().toISOString(),
-        };
-
-      // DEPRECATED: Workflow Execution Tools - Handlers removed for 5 deprecated workflow tools
-      // Removed cases: workflow_execute, parallel_execute, batch_process, workflow_export, workflow_template
-      // Retained: workflow_create (basic functionality)
-      // Rationale: Workflow execution integrated into task_orchestrate
-      // Note: Workflow implementation files (workflow-tools.js) retained for backward compatibility
-
-      // Performance Tools Implementation
-      case 'performance_report':
-        if (global.performanceMonitor) {
-          return global.performanceMonitor.performance_report(args);
-        }
-        return {
-          success: false,
-          error: 'Performance monitor not initialized',
-          timestamp: new Date().toISOString(),
-        };
-
-      case 'bottleneck_analyze':
-        if (global.performanceMonitor) {
-          return global.performanceMonitor.bottleneck_analyze(args);
-        }
-        return {
-          success: false,
-          error: 'Performance monitor not initialized',
-          timestamp: new Date().toISOString(),
-        };
-
-      case 'memory_analytics':
-        if (global.performanceMonitor) {
-          return global.performanceMonitor.memory_analytics(args);
+            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to get active swarm:`, error);
+            return null;
         }
-        return {
-          success: false,
-          error: 'Performance monitor not initialized',
-          timestamp: new Date().toISOString(),
-        };
-
-      default:
-        return {
-          success: true,
-          tool: name,
-          message: `Tool ${name} executed successfully`,
-          args: args,
-          timestamp: new Date().toISOString(),
-        };
     }
-  }
-
-  async readResource(uri) {
-    switch (uri) {
-      case 'claude-flow://swarms':
-        return {
-          active_swarms: 3,
-          total_agents: 15,
-          topologies: ['hierarchical', 'mesh', 'ring', 'star'],
-          performance: '2.8-4.4x speedup',
-        };
-
-      case 'claude-flow://agents':
-        return {
-          total_agents: 8,
-          types: [
-            'researcher',
-            'coder',
-            'analyst',
-            'architect',
-            'tester',
-            'coordinator',
-            'reviewer',
-            'optimizer',
-          ],
-          active: 15,
-          capabilities: 127,
-        };
-
-      case 'claude-flow://models':
-        return {
-          total_models: 27,
-          wasm_enabled: true,
-          simd_support: true,
-          training_active: true,
-          accuracy_avg: 0.89,
-        };
-
-      case 'claude-flow://performance':
-        return {
-          uptime: '99.9%',
-          token_reduction: '32.3%',
-          swe_bench_rate: '84.8%',
-          speed_improvement: '2.8-4.4x',
-          memory_efficiency: '78%',
+    createErrorResponse(id, code, message, data = null) {
+        const response = {
+            jsonrpc: '2.0',
+            id,
+            error: {
+                code,
+                message
+            }
         };
-
-      default:
-        throw new Error(`Unknown resource: ${uri}`);
-    }
-  }
-
-  async handleMemoryUsage(args) {
-    if (!this.memoryStore) {
-      return {
-        success: false,
-        error: 'Shared memory system not initialized',
-        timestamp: new Date().toISOString(),
-      };
+        if (data) response.error.data = data;
+        return response;
     }
-
-    try {
-      switch (args.action) {
-        case 'store':
-          const storeResult = await this.memoryStore.store(args.key, args.value, {
-            namespace: args.namespace || 'default',
-            ttl: args.ttl,
-            metadata: {
-              sessionId: this.sessionId,
-              storedBy: 'mcp-server',
-              type: 'knowledge',
+    constructor(){
+        this.version = '2.0.0-alpha.59';
+        this.memoryStore = memoryStore; // Use shared singleton instance
+        // Use the same memory system that already works
+        this.capabilities = {
+            tools: {
+                listChanged: true
             },
-          });
-
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Stored in shared memory: ${args.key} (namespace: ${args.namespace || 'default'})`,
-          );
-
-          return {
-            success: true,
-            action: 'store',
-            key: args.key,
-            namespace: args.namespace || 'default',
-            stored: true,
-            size: storeResult.size || args.value.length,
-            id: storeResult.id,
-            storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
-            timestamp: new Date().toISOString(),
-          };
-
-        case 'retrieve':
-          const value = await this.memoryStore.retrieve(args.key, {
-            namespace: args.namespace || 'default',
-          });
-
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Retrieved from shared memory: ${args.key} (found: ${value !== null})`,
-          );
-
-          return {
-            success: true,
-            action: 'retrieve',
-            key: args.key,
-            value: value,
-            found: value !== null,
-            namespace: args.namespace || 'default',
-            storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
-            timestamp: new Date().toISOString(),
-          };
-
-        case 'list':
-          const entries = await this.memoryStore.list({
-            namespace: args.namespace || 'default',
-            limit: 100,
-          });
-
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Listed shared memory entries: ${entries.length} (namespace: ${args.namespace || 'default'})`,
-          );
-
-          return {
-            success: true,
-            action: 'list',
-            namespace: args.namespace || 'default',
-            entries: entries,
-            count: entries.length,
-            storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
-            timestamp: new Date().toISOString(),
-          };
-
-        case 'delete':
-          const deleted = await this.memoryStore.delete(args.key, {
-            namespace: args.namespace || 'default',
-          });
-
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Deleted from shared memory: ${args.key} (success: ${deleted})`,
-          );
-
-          return {
-            success: true,
-            action: 'delete',
-            key: args.key,
-            namespace: args.namespace || 'default',
-            deleted: deleted,
-            storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
-            timestamp: new Date().toISOString(),
-          };
-
-        case 'search':
-          const results = await this.memoryStore.search(args.value || '', {
-            namespace: args.namespace || 'default',
-            limit: 50,
-          });
-
-          console.error(
-            `[${new Date().toISOString()}] INFO [claude-flow-mcp] Searched shared memory: ${results.length} results for "${args.value}"`,
-          );
-
-          return {
-            success: true,
-            action: 'search',
-            pattern: args.value,
-            namespace: args.namespace || 'default',
-            results: results,
-            count: results.length,
-            storage_type: this.memoryStore.isUsingFallback() ? 'in-memory' : 'sqlite',
-            timestamp: new Date().toISOString(),
-          };
-
-        default:
-          return {
-            success: false,
-            error: `Unknown memory action: ${args.action}`,
-            timestamp: new Date().toISOString(),
-          };
-      }
-    } catch (error) {
-      console.error(
-        `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Shared memory operation failed:`,
-        error,
-      );
-      return {
-        success: false,
-        error: error.message,
-        action: args.action,
-        storage_type: this.memoryStore?.isUsingFallback() ? 'in-memory' : 'sqlite',
-        timestamp: new Date().toISOString(),
-      };
-    }
-  }
-
-  async handleMemorySearch(args) {
-    if (!this.memoryStore) {
-      return {
-        success: false,
-        error: 'Memory system not initialized',
-        timestamp: new Date().toISOString(),
-      };
-    }
-
-    try {
-      const results = await this.sharedMemory.search(args.pattern, {
-        namespace: args.namespace || 'default',
-        limit: args.limit || 10,
-      });
-
-      return {
-        success: true,
-        pattern: args.pattern,
-        namespace: args.namespace || 'default',
-        results: results,
-        count: results.length,
-        timestamp: new Date().toISOString(),
-      };
-    } catch (error) {
-      console.error(
-        `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Memory search failed:`,
-        error,
-      );
-      return {
-        success: false,
-        error: error.message,
-        timestamp: new Date().toISOString(),
-      };
-    }
-  }
-
-  async getActiveSwarmId() {
-    try {
-      const activeSwarmId = await this.memoryStore.retrieve('active_swarm', {
-        namespace: 'system',
-      });
-      return activeSwarmId || null;
-    } catch (error) {
-      console.error(
-        `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to get active swarm:`,
-        error,
-      );
-      return null;
+            resources: {
+                subscribe: true,
+                listChanged: true
+            }
+        };
+        this.sessionId = `session-cf-${Date.now()}-${Math.random().toString(36).substr(2, 4)}`;
+        this.tools = this.initializeTools();
+        this.resources = this.initializeResources();
+        // Initialize shared memory store (same as npx commands)
+        this.initializeMemory().catch((err)=>{
+            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to initialize shared memory:`, err);
+        });
+    // Database operations now use the same shared memory store as npx commands
     }
-  }
-
-  createErrorResponse(id, code, message, data = null) {
-    const response = {
-      jsonrpc: '2.0',
-      id,
-      error: { code, message },
-    };
-    if (data) response.error.data = data;
-    return response;
-  }
-}
-
+};
 // Main server execution
 async function startMCPServer() {
-  const server = new ClaudeFlowMCPServer();
-
-  console.error(
-    `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Claude-Flow MCP server starting in stdio mode`,
-  );
-  console.error({
-    arch: process.arch,
-    mode: 'mcp-stdio',
-    nodeVersion: process.version,
-    pid: process.pid,
-    platform: process.platform,
-    protocol: 'stdio',
-    sessionId: server.sessionId,
-    version: server.version,
-  });
-
-  // Send server capabilities
-  console.log(
-    JSON.stringify({
-      jsonrpc: '2.0',
-      method: 'server.initialized',
-      params: {
-        serverInfo: {
-          name: 'claude-flow',
-          version: server.version,
-          capabilities: server.capabilities,
-        },
-      },
-    }),
-  );
-
-  // Handle stdin messages
-  let buffer = '';
-
-  process.stdin.on('data', async (chunk) => {
-    buffer += chunk.toString();
-
-    // Process complete JSON messages
-    let lines = buffer.split('\n');
-    buffer = lines.pop() || ''; // Keep incomplete line in buffer
-
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const message = JSON.parse(line);
-          const response = await server.handleMessage(message);
-          if (response) {
-            console.log(JSON.stringify(response));
-          }
-        } catch (error) {
-          console.error(
-            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse message:`,
-            error.message,
-          );
+    const server = new ClaudeFlowMCPServer();
+    console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Claude-Flow MCP server starting in stdio mode`);
+    console.error({
+        arch: process.arch,
+        mode: 'mcp-stdio',
+        nodeVersion: process.version,
+        pid: process.pid,
+        platform: process.platform,
+        protocol: 'stdio',
+        sessionId: server.sessionId,
+        version: server.version
+    });
+    // Send server capabilities
+    console.log(JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'server.initialized',
+        params: {
+            serverInfo: {
+                name: 'claude-flow',
+                version: server.version,
+                capabilities: server.capabilities
+            }
         }
-      }
-    }
-  });
-
-  process.stdin.on('end', () => {
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) 🔌 Connection closed: ${server.sessionId}`,
-    );
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) MCP: stdin closed, shutting down...`,
-    );
-    process.exit(0);
-  });
-
-  // Handle process termination
-  process.on('SIGINT', async () => {
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Received SIGINT, shutting down gracefully...`,
-    );
-    if (server.sharedMemory) {
-      await server.sharedMemory.close();
-    }
-    process.exit(0);
-  });
-
-  process.on('SIGTERM', async () => {
-    console.error(
-      `[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Received SIGTERM, shutting down gracefully...`,
-    );
-    if (server.sharedMemory) {
-      await server.sharedMemory.close();
-    }
-    process.exit(0);
-  });
+    }));
+    // Handle stdin messages
+    let buffer = '';
+    process.stdin.on('data', async (chunk)=>{
+        buffer += chunk.toString();
+        // Process complete JSON messages
+        let lines = buffer.split('\n');
+        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+        for (const line of lines){
+            if (line.trim()) {
+                try {
+                    const message = JSON.parse(line);
+                    const response = await server.handleMessage(message);
+                    if (response) {
+                        console.log(JSON.stringify(response));
+                    }
+                } catch (error) {
+                    console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to parse message:`, error.message);
+                }
+            }
+        }
+    });
+    process.stdin.on('end', ()=>{
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) 🔌 Connection closed: ${server.sessionId}`);
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) MCP: stdin closed, shutting down...`);
+        process.exit(0);
+    });
+    // Handle process termination
+    process.on('SIGINT', async ()=>{
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Received SIGINT, shutting down gracefully...`);
+        if (server.sharedMemory) {
+            await server.sharedMemory.close();
+        }
+        process.exit(0);
+    });
+    process.on('SIGTERM', async ()=>{
+        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${server.sessionId}) Received SIGTERM, shutting down gracefully...`);
+        if (server.sharedMemory) {
+            await server.sharedMemory.close();
+        }
+        process.exit(0);
+    });
 }
-
 // Start the server if this file is run directly
 if (import.meta.url === `file://${process.argv[1]}`) {
-  startMCPServer().catch(console.error);
+    startMCPServer().catch(console.error);
 }
-
 export { ClaudeFlowMCPServer };