claude-flow-novice 2.0.4 → 2.0.5

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

@@ -3,1688 +3,1552 @@
  * ⚠️ 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);
-import path from "path";
-import { fileURLToPath } from "url";
+
+/* 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';
 // 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;
 }
-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`);
-    }
-    // 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'
-                    ]
-                }
+
+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',
+              ],
             },
-            github_metrics: {
-                name: 'github_metrics',
-                description: 'Repository metrics',
-                inputSchema: {
-                    type: 'object',
-                    properties: {
-                        repo: {
-                            type: 'string'
-                        }
-                    },
-                    required: [
-                        'repo'
-                    ]
-                }
-            }
-        };
+            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);
     }
-    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'
+  }
+
+  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),
             },
-            'claude-flow://models': {
-                uri: 'claude-flow://models',
-                name: 'Neural Models',
-                description: 'Available neural network models and training status',
-                mimeType: 'application/json'
+          ],
+        },
+      };
+    } 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),
             },
-            'claude-flow://performance': {
-                uri: 'claude-flow://performance',
-                name: 'Performance Metrics',
-                description: 'Real-time performance metrics and benchmarks',
-                mimeType: 'application/json'
-            }
-        };
+          ],
+        },
+      };
+    } catch (error) {
+      return this.createErrorResponse(id, -32000, 'Resource read failed', error.message);
     }
-    async handleMessage(message) {
+  }
+
+  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',
+          }),
+        };
+
+        // Store swarm data in memory store (same as npx commands)
         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');
-            }
+          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) {
-            return this.createErrorResponse(message.id, -32603, 'Internal error', error.message);
+          console.error(
+            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist swarm:`,
+            error,
+          );
         }
-    }
-    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
-                }
-            }
+          success: true,
+          swarmId: swarmId,
+          topology: swarmData.topology,
+          maxAgents: swarmData.maxAgents,
+          strategy: args.strategy || 'auto',
+          status: 'initialized',
+          persisted: !!this.databaseManager,
+          timestamp: new Date().toISOString(),
         };
-    }
-    handleToolsList(id) {
-        const toolsList = Object.values(this.tools);
-        return {
-            jsonrpc: '2.0',
-            id,
-            result: {
-                tools: toolsList
-            }
+
+      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(),
+          }),
         };
-    }
-    async handleToolCall(id, params) {
-        const { name, arguments: args } = params;
-        console.error(`[${new Date().toISOString()}] INFO [claude-flow-mcp] (${this.sessionId}) 🔧 Tool called: ${name}`);
+
+        // Store agent data in memory store (same as npx commands)
         try {
-            const result = await this.executeTool(name, args);
-            return {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2)
-                        }
-                    ]
-                }
-            };
+          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) {
-            return this.createErrorResponse(id, -32000, 'Tool execution failed', error.message);
+          console.error(
+            `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to persist agent:`,
+            error,
+          );
         }
-    }
-    handleResourcesList(id) {
-        const resourcesList = Object.values(this.resources);
+
+        // Track spawned agent
+        if (global.agentTracker) {
+          global.agentTracker.trackAgent(agentId, {
+            ...agentData,
+            capabilities: args.capabilities || [],
+          });
+        }
+
         return {
-            jsonrpc: '2.0',
-            id,
-            result: {
-                resources: resourcesList
-            }
+          success: true,
+          agentId: agentId,
+          type: args.type,
+          name: agentData.name,
+          status: 'active',
+          capabilities: args.capabilities || [],
+          persisted: !!this.databaseManager,
+          timestamp: new Date().toISOString(),
         };
-    }
-    async handleResourceRead(id, params) {
-        const { uri } = params;
-        try {
-            const content = await this.readResource(uri);
+
+      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 {
-                jsonrpc: '2.0',
-                id,
-                result: {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: 'application/json',
-                            text: JSON.stringify(content, null, 2)
-                        }
-                    ]
-                }
+              success: true,
+              swarmId: swarmId || 'dynamic',
+              agents: trackedAgents,
+              count: trackedAgents.length,
+              timestamp: new Date().toISOString(),
             };
-        } catch (error) {
-            return this.createErrorResponse(id, -32000, 'Resource read failed', error.message);
+          }
         }
-    }
-    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 {
+
+        if (this.databaseManager) {
+          try {
+            const swarmId = args.swarmId || (await this.getActiveSwarmId());
+            if (!swarmId) {
+              return {
                 success: false,
-                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()
-                    };
+                error: 'No active swarm found',
+                agents: [],
+                timestamp: new Date().toISOString(),
+              };
             }
-        } catch (error) {
-            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Shared memory operation failed:`, error);
+
+            const agents = await this.databaseManager.getAgents(swarmId);
             return {
-                success: false,
-                error: error.message,
-                action: args.action,
-                storage_type: this.memoryStore?.isUsingFallback() ? 'in-memory' : 'sqlite',
-                timestamp: new Date().toISOString()
+              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(),
             };
-        }
-    }
-    async handleMemorySearch(args) {
-        if (!this.memoryStore) {
+          } catch (error) {
+            console.error(
+              `[${new Date().toISOString()}] ERROR [claude-flow-mcp] Failed to list agents:`,
+              error,
+            );
             return {
-                success: false,
-                error: 'Memory system not initialized',
-                timestamp: new Date().toISOString()
+              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 {
-            const results = await this.sharedMemory.search(args.pattern, {
-                namespace: args.namespace || 'default',
-                limit: args.limit || 10
+          // 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: true,
-                pattern: args.pattern,
-                namespace: args.namespace || 'default',
-                results: results,
-                count: results.length,
-                timestamp: new Date().toISOString()
+              success: false,
+              error: 'No active swarm found',
+              timestamp: new Date().toISOString(),
             };
-        } catch (error) {
-            console.error(`[${new Date().toISOString()}] ERROR [claude-flow-mcp] Memory search failed:`, error);
+          }
+
+          // 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: error.message,
-                timestamp: new Date().toISOString()
+              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(),
+          };
         }
-    }
-    async getActiveSwarmId() {
+
+      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 {
-            const activeSwarmId = await this.memoryStore.retrieve('active_swarm', {
-                namespace: 'system'
-            });
-            return activeSwarmId || null;
+          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 get active swarm:`, error);
-            return null;
+          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(),
+        };
     }
-    createErrorResponse(id, code, message, data = null) {
-        const response = {
-            jsonrpc: '2.0',
-            id,
-            error: {
-                code,
-                message
-            }
+  }
+
+  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,
         };
-        if (data) response.error.data = data;
-        return response;
+
+      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: 'Shared memory system not initialized',
+        timestamp: new Date().toISOString(),
+      };
     }
-    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
+
+    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',
             },
-            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
+          });
+
+          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;
+    }
+  }
+
+  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);
-                }
-            }
-        }
-    });
-    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();
+  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,
+          );
         }
-        process.exit(0);
-    });
+      }
+    }
+  });
+
+  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 };