claude-flow 2.0.0-alpha.62 → 2.0.0-alpha.63

package/.claude/commands/swarm/testing.md

@@ -4,16 +4,128 @@
 Comprehensive testing through distributed execution.
 
 ## Activation
-`./claude-flow swarm "test application" --strategy testing`
+
+### Using MCP Tools
+```javascript
+// Initialize testing swarm
+mcp__claude-flow__swarm_init({
+  "topology": "star",
+  "maxAgents": 7,
+  "strategy": "parallel"
+})
+
+// Orchestrate testing task
+mcp__claude-flow__task_orchestrate({
+  "task": "test application",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx claude-flow swarm "test application" --strategy testing`
 
 ## Agent Roles
-- Unit Tester: Tests individual components
-- Integration Tester: Validates interactions
-- E2E Tester: Tests user flows
-- Performance Tester: Measures metrics
-- Security Tester: Finds vulnerabilities
+
+### Agent Spawning with MCP
+```javascript
+// Spawn testing agents
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Unit Tester",
+  "capabilities": ["unit-testing", "mocking", "coverage"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Integration Tester",
+  "capabilities": ["integration", "api-testing", "contract-testing"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "E2E Tester",
+  "capabilities": ["e2e", "ui-testing", "user-flows"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "tester",
+  "name": "Performance Tester",
+  "capabilities": ["load-testing", "stress-testing", "benchmarking"]
+})
+
+mcp__claude-flow__agent_spawn({
+  "type": "monitor",
+  "name": "Security Tester",
+  "capabilities": ["security-testing", "penetration-testing", "vulnerability-scanning"]
+})
+```
 
 ## Test Coverage
-- Code coverage analysis
-- Edge case identification
-- Regression prevention
+
+### Coverage Analysis
+```javascript
+// Quality assessment
+mcp__claude-flow__quality_assess({
+  "target": "test-coverage",
+  "criteria": ["line-coverage", "branch-coverage", "function-coverage"]
+})
+
+// Edge case detection
+mcp__claude-flow__pattern_recognize({
+  "data": testScenarios,
+  "patterns": ["edge-case", "boundary-condition", "error-path"]
+})
+```
+
+### Test Execution
+```javascript
+// Parallel test execution
+mcp__claude-flow__parallel_execute({
+  "tasks": [
+    { "id": "unit-tests", "command": "npm run test:unit" },
+    { "id": "integration-tests", "command": "npm run test:integration" },
+    { "id": "e2e-tests", "command": "npm run test:e2e" }
+  ]
+})
+
+// Batch processing for test suites
+mcp__claude-flow__batch_process({
+  "items": testSuites,
+  "operation": "execute-test-suite"
+})
+```
+
+### Performance Testing
+```javascript
+// Run performance benchmarks
+mcp__claude-flow__benchmark_run({
+  "suite": "performance-tests"
+})
+
+// Security scanning
+mcp__claude-flow__security_scan({
+  "target": "application",
+  "depth": "comprehensive"
+})
+```
+
+### Monitoring and Reporting
+```javascript
+// Monitor test execution
+mcp__claude-flow__swarm_monitor({
+  "swarmId": "testing-swarm",
+  "interval": 2000
+})
+
+// Generate test report
+mcp__claude-flow__performance_report({
+  "format": "detailed",
+  "timeframe": "current-run"
+})
+
+// Get test results
+mcp__claude-flow__task_results({
+  "taskId": "test-execution-001"
+})
+```

package/.claude/commands/training/neural-patterns.md

@@ -15,7 +15,11 @@ Every successful operation trains the neural networks:
 ### 2. Manual Training
 ```
 Tool: mcp__claude-flow__neural_train
-Parameters: {"iterations": 20}
+Parameters: {
+  "pattern_type": "coordination",
+  "training_data": "successful task patterns",
+  "epochs": 50
+}
 ```
 
 ### 3. Pattern Types
@@ -42,8 +46,29 @@ Result: {
 }
 ```
 
+## Pattern Analysis
+```
+Tool: mcp__claude-flow__neural_patterns
+Parameters: {
+  "action": "analyze",
+  "operation": "recent_edits"
+}
+```
+
 ## Benefits
 - 🧠 Learns your coding style
 - 📈 Improves with each use
 - 🎯 Better task predictions
-- ⚡ Faster coordination
+- ⚡ Faster coordination
+
+## CLI Usage
+```bash
+# Train neural patterns via CLI
+npx claude-flow neural train --type coordination --epochs 50
+
+# Check neural status
+npx claude-flow neural status
+
+# Analyze patterns
+npx claude-flow neural patterns --analyze
+```

package/.claude/commands/training/specialization.md

@@ -17,7 +17,8 @@ Agents automatically specialize based on file extensions:
 Tool: mcp__claude-flow__agent_spawn
 Parameters: {
   "type": "coder",
-  "capabilities": ["react", "typescript", "testing"]
+  "capabilities": ["react", "typescript", "testing"],
+  "name": "React Specialist"
 }
 ```
 
@@ -32,7 +33,7 @@ The system trains through:
 ```
 # Check agent specializations
 Tool: mcp__claude-flow__agent_list
-Parameters: {"filter": "active"}
+Parameters: {"swarmId": "current"}
 
 Result shows expertise levels:
 {
@@ -50,4 +51,13 @@ Result shows expertise levels:
 ```
 
 ## Continuous Improvement
-Agents share learnings across sessions for cumulative expertise!
+Agents share learnings across sessions for cumulative expertise!
+
+## CLI Usage
+```bash
+# Train agent specialization via CLI
+npx claude-flow train agent --type coder --capabilities "react,typescript"
+
+# Check specializations
+npx claude-flow agent list --specializations
+```

package/.claude/commands/workflows/development.md

@@ -15,18 +15,45 @@ Creates hierarchical structure for organized, top-down development.
 ### 2. Define Development Perspectives
 ```
 Tool: mcp__claude-flow__agent_spawn
-Parameters: {"type": "architect", "name": "System Design"}
+Parameters: {
+  "type": "architect",
+  "name": "System Design",
+  "capabilities": ["api-design", "database-schema"]
+}
 ```
 ```
 Tool: mcp__claude-flow__agent_spawn
-Parameters: {"type": "coder", "name": "Implementation Focus"}
+Parameters: {
+  "type": "coder",
+  "name": "Implementation Focus",
+  "capabilities": ["nodejs", "typescript", "express"]
+}
+```
+```
+Tool: mcp__claude-flow__agent_spawn
+Parameters: {
+  "type": "tester",
+  "name": "Quality Assurance",
+  "capabilities": ["unit-testing", "integration-testing"]
+}
 ```
 Sets up architectural and implementation thinking patterns.
 
 ### 3. Coordinate Implementation
 ```
 Tool: mcp__claude-flow__task_orchestrate
-Parameters: {"task": "Build REST API with authentication", "strategy": "parallel", "priority": "high"}
+Parameters: {
+  "task": "Build REST API with authentication",
+  "strategy": "parallel",
+  "priority": "high",
+  "dependencies": ["database setup", "auth system"]
+}
+```
+
+### 4. Monitor Progress
+```
+Tool: mcp__claude-flow__task_status
+Parameters: {"taskId": "api-build-task-123"}
 ```
 
 ## What Claude Code Actually Does
@@ -36,4 +63,16 @@ Parameters: {"task": "Build REST API with authentication", "strategy": "parallel
 4. Uses **TodoWrite** tool for task tracking
 5. Follows coordination patterns for systematic implementation
 
-Remember: All code is written by Claude Code using its native tools!
+Remember: All code is written by Claude Code using its native tools!
+
+## CLI Usage
+```bash
+# Start development workflow via CLI
+npx claude-flow workflow dev "REST API with auth"
+
+# Create custom workflow
+npx claude-flow workflow create --name "api-dev" --steps "design,implement,test,deploy"
+
+# Execute saved workflow
+npx claude-flow workflow execute api-dev
+```

package/.claude/commands/workflows/research.md

@@ -26,7 +26,22 @@ Sets up different analytical approaches for Claude Code to use.
 ### 3. Execute Coordinated Research
 ```
 Tool: mcp__claude-flow__task_orchestrate
-Parameters: {"task": "Research modern web frameworks performance", "strategy": "adaptive"}
+Parameters: {
+  "task": "Research modern web frameworks performance",
+  "strategy": "adaptive",
+  "priority": "medium"
+}
+```
+
+### 4. Store Research Findings
+```
+Tool: mcp__claude-flow__memory_usage
+Parameters: {
+  "action": "store",
+  "key": "research_findings",
+  "value": "framework performance analysis results",
+  "namespace": "research"
+}
 ```
 
 ## What Claude Code Actually Does
@@ -36,4 +51,13 @@ Parameters: {"task": "Research modern web frameworks performance", "strategy": "
 4. Synthesizes findings using coordination patterns
 5. Stores insights in memory for future reference
 
-Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
+Remember: The swarm coordinates HOW Claude Code researches, not WHAT it finds.
+
+## CLI Usage
+```bash
+# Start research workflow via CLI
+npx claude-flow workflow research "modern web frameworks"
+
+# Export research workflow
+npx claude-flow workflow export research --format json
+```

package/README.md

@@ -35,6 +35,10 @@
 
 ### 📋 **Prerequisites**
 
+- **Node.js 18+** (LTS recommended)
+- **npm 9+** or equivalent package manager
+- **Windows users**: See [Windows Installation Guide](https://github.com/ruvnet/claude-code-flow/blob/main/docs/windows-installation.md) for special instructions
+
 ⚠️ **IMPORTANT**: Claude Code must be installed first:
 
 ```bash
@@ -45,6 +49,8 @@ npm install -g @anthropic-ai/claude-code
 claude --dangerously-skip-permissions
 ```
 
+💡 **Windows Note**: If you encounter SQLite errors, Claude Flow will automatically use in-memory storage. For persistent storage options, see our [Windows guide](https://github.com/ruvnet/claude-code-flow/blob/main/docs/windows-installation.md).
+
 ### 🎯 **Instant Alpha Testing**
 
 ```bash
@@ -301,6 +307,8 @@ npx claude-flow@alpha memory export backup.json --namespace default
 npx claude-flow@alpha memory import project-memory.json
 ```
 
+> 🪟 **Windows Users**: SQLite will automatically fallback to in-memory storage if native modules fail. All features work normally, but data won't persist between sessions. See [Windows guide](https://github.com/ruvnet/claude-code-flow/blob/main/docs/windows-installation.md) for persistent storage options.
+
 ### **🔄 Workflow Orchestration**
 ```bash
 # Advanced workflow automation

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.0.0-alpha.62"
+VERSION="2.0.0-alpha.63"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

package/dist/cli/simple-commands/hive-mind/mcp-wrapper.d.ts

@@ -188,6 +188,72 @@ export class MCPToolWrapper {
      * Clean up and destroy swarm
      */
     destroySwarm(swarmId: any): Promise<any[]>;
+    /**
+     * Get real swarm status from memory storage
+     */
+    getSwarmStatus(params?: {}): Promise<{
+        swarms: {
+            id: any;
+            name: any;
+            status: string;
+            agents: number;
+            tasks: {
+                total: number;
+                completed: number;
+                pending: number;
+                failed: number;
+            };
+            topology: string;
+            createdAt: null;
+            lastActivity: null;
+            memoryUsage: number;
+        }[];
+        activeAgents: number;
+        totalTasks: number;
+        completedTasks: number;
+        pendingTasks: number;
+        recentActivity: {
+            swarmId: any;
+            action: any;
+            type: any;
+            timestamp: any;
+        }[];
+        summary: {
+            totalSwarms: number;
+            activeSwarms: number;
+            idleSwarms: number;
+            inactiveSwarms: number;
+        };
+        error?: undefined;
+    } | {
+        swarms: any[];
+        activeAgents: number;
+        totalTasks: number;
+        completedTasks: number;
+        pendingTasks: number;
+        summary: {
+            totalSwarms: number;
+            activeSwarms: number;
+            idleSwarms?: undefined;
+            inactiveSwarms?: undefined;
+        };
+        recentActivity?: undefined;
+        error?: undefined;
+    } | {
+        swarms: never[];
+        activeAgents: number;
+        totalTasks: number;
+        completedTasks: number;
+        pendingTasks: number;
+        recentActivity: never[];
+        summary: {
+            totalSwarms: number;
+            activeSwarms: number;
+            idleSwarms: number;
+            inactiveSwarms: number;
+        };
+        error: any;
+    }>;
 }
 export namespace MCP_TOOLS {
     let swarm: string[];

package/dist/cli/simple-commands/hive-mind/mcp-wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/hive-mind/mcp-wrapper.js"],"names":[],"mappings":"AAmHA;;GAEG;AACH;IACE,yBAiBC;IAhBC;;;;MAKC;IAED,yBAA0B;IAC1B,qBAAuB;IACvB,mBAAsB;IAEtB,uDAAuD;IACvD,UADW,OAAO,gBAAgB,EAAE,QAAQ,GAAG,IAAI,CAC/B;IAMtB;;OAEG;IACH,yCAuCC;IAFG,uCAA4B;IAIhC;;OAEG;IACH,sDA6BC;IAED;;OAEG;IACH,gDA8DC;IAED;;OAEG;IACH,qDAcC;IAED;;OAEG;IACH,iDA2BC;IAED;;OAEG;IACH,2DAgBC;IAED;;OAEG;IACH,mFAoBC;IAlBG;;;;;;;kBAOC;IAaL;;OAEG;IACH,+DA0BC;IAED;;OAEG;IACH,+CAOC;IAED;;OAEG;IACH,kDA+BC;IAED;;OAEG;IACH,kEAoBC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;MA+BC;IAED;;OAEG;IACH,6CAQC;IAED;;OAEG;IACH,mCAMC;IAED;;OAEG;IACH,mCAKC;IAED;;OAEG;IACH,6BAKC;IAED;;OAEG;IACH,6CAwDC;IAED;;OAEG;IACH,sDAqCC;IAED;;OAEG;IACH,oCA4BC;IAED;;OAEG;IACH,8DAkBC;IAhBG;;;;;;;kBAOC;IAWL;;OAEG;IACH;;;;;;;;;;;;;;;;OAmDC;IAED;;OAEG;IACH,qDA4CC;IAED;;OAEG;IACH;;;;;;OAqFC;IAED;;OAEG;IACH,6EA2CC;IAED;;OAEG;IACH,iDAQC;IAED;;OAEG;IACH,uEAcC;IAED;;OAEG;IACH,2DAcC;IAED;;OAEG;IACH,2CAoBC;CACF"}
+{"version":3,"file":"mcp-wrapper.d.ts","sourceRoot":"","sources":["../../../../src/cli/simple-commands/hive-mind/mcp-wrapper.js"],"names":[],"mappings":"AAmHA;;GAEG;AACH;IACE,yBAiBC;IAhBC;;;;MAKC;IAED,yBAA0B;IAC1B,qBAAuB;IACvB,mBAAsB;IAEtB,uDAAuD;IACvD,UADW,OAAO,gBAAgB,EAAE,QAAQ,GAAG,IAAI,CAC/B;IAMtB;;OAEG;IACH,yCAuCC;IAFG,uCAA4B;IAIhC;;OAEG;IACH,sDA6BC;IAED;;OAEG;IACH,gDA8DC;IAED;;OAEG;IACH,qDAcC;IAED;;OAEG;IACH,iDA2BC;IAED;;OAEG;IACH,2DAgBC;IAED;;OAEG;IACH,mFAoBC;IAlBG;;;;;;;kBAOC;IAaL;;OAEG;IACH,+DA4BC;IAED;;OAEG;IACH,+CAOC;IAED;;OAEG;IACH,kDA+BC;IAED;;OAEG;IACH,kEAoBC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;MA+BC;IAED;;OAEG;IACH,6CAQC;IAED;;OAEG;IACH,mCAMC;IAED;;OAEG;IACH,mCAKC;IAED;;OAEG;IACH,6BAKC;IAED;;OAEG;IACH,6CA6EC;IAED;;OAEG;IACH,sDAqCC;IAED;;OAEG;IACH,oCA4BC;IAED;;OAEG;IACH,8DAkBC;IAhBG;;;;;;;kBAOC;IAWL;;OAEG;IACH;;;;;;;;;;;;;;;;OAmDC;IAED;;OAEG;IACH,qDA4CC;IAED;;OAEG;IACH;;;;;;OAqFC;IAED;;OAEG;IACH,6EA2CC;IAED;;OAEG;IACH,iDAQC;IAED;;OAEG;IACH,uEAcC;IAED;;OAEG;IACH,2DAcC;IAED;;OAEG;IACH,2CAoBC;IAED;;OAEG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsNC;CACF"}

package/dist/cli/simple-commands/hive-mind/mcp-wrapper.js

@@ -352,6 +352,9 @@ export class MCPToolWrapper {
         else if (toolName === 'memory_search') {
             return await this.searchMemory(params.namespace, params.pattern);
         }
+        else if (toolName === 'swarm_status') {
+            return await this.getSwarmStatus(params);
+        }
         // For other tools, use mock responses
         console.log(`Executing MCP tool: mcp__claude-flow__${toolName} with params:`, params);
         // Simulate async execution for non-memory tools
@@ -538,10 +541,19 @@ export class MCPToolWrapper {
             const initTime = Date.now() - startTime;
             await this.storeMemory(swarmId, 'init_performance', {
                 initTime,
-                topology: config.topology,
-                maxAgents: config.maxAgents,
+                topology: config.topology || 'hierarchical',
+                maxAgents: config.maxAgents || 8,
                 timestamp: Date.now(),
             }, 'metrics');
+            // Store swarm status
+            await this.storeMemory(swarmId, 'status', 'active', 'status');
+            // Store swarm config
+            await this.storeMemory(swarmId, 'config', {
+                topology: config.topology || 'hierarchical',
+                maxAgents: config.maxAgents || 8,
+                strategy: config.strategy || 'auto',
+                createdAt: Date.now(),
+            }, 'config');
             return [swarmInitResult, ...supportingResults];
         }
         catch (error) {
@@ -930,6 +942,212 @@ export class MCPToolWrapper {
         ];
         return await this.executeParallel(batch);
     }
+    /**
+     * Get real swarm status from memory storage
+     */
+    async getSwarmStatus(params = {}) {
+        try {
+            if (!this.memoryDb) {
+                await this.initializeMemoryStorage();
+            }
+            const swarms = [];
+            let activeAgents = 0;
+            let totalTasks = 0;
+            let completedTasks = 0;
+            if (this.memoryDb) {
+                // Get all unique swarm namespaces
+                const namespacesQuery = this.memoryDb.prepare(`
+          SELECT DISTINCT namespace FROM memories 
+          WHERE namespace LIKE 'swarm-%' OR namespace LIKE 'hive-%'
+          ORDER BY timestamp DESC
+        `);
+                const namespaces = namespacesQuery.all();
+                // For each swarm, gather its information
+                for (const { namespace } of namespaces) {
+                    const swarmId = namespace;
+                    // Get swarm metadata
+                    const metadataQuery = this.memoryDb.prepare(`
+            SELECT key, value, type, timestamp FROM memories 
+            WHERE namespace = ? AND (
+              key IN ('init_performance', 'config', 'status', 'agents', 'tasks', 'topology')
+              OR key LIKE 'agent-%'
+              OR key LIKE 'task-%'
+            )
+          `);
+                    const swarmData = metadataQuery.all(swarmId);
+                    // Parse swarm information
+                    let swarmInfo = {
+                        id: swarmId,
+                        name: swarmId,
+                        status: 'unknown',
+                        agents: 0,
+                        tasks: { total: 0, completed: 0, pending: 0, failed: 0 },
+                        topology: 'hierarchical',
+                        createdAt: null,
+                        lastActivity: null,
+                        memoryUsage: swarmData.length
+                    };
+                    // Process swarm data
+                    for (const record of swarmData) {
+                        try {
+                            const value = typeof record.value === 'string' ? JSON.parse(record.value) : record.value;
+                            switch (record.key) {
+                                case 'init_performance':
+                                    swarmInfo.createdAt = value.timestamp;
+                                    swarmInfo.topology = value.topology || 'hierarchical';
+                                    break;
+                                case 'status':
+                                    swarmInfo.status = value;
+                                    break;
+                                case 'config':
+                                    swarmInfo.topology = value.topology || swarmInfo.topology;
+                                    break;
+                            }
+                            // Count agents
+                            if (record.key.startsWith('agent-')) {
+                                swarmInfo.agents++;
+                                activeAgents++;
+                            }
+                            // Count tasks
+                            if (record.key.startsWith('task-')) {
+                                swarmInfo.tasks.total++;
+                                totalTasks++;
+                                if (value.status === 'completed') {
+                                    swarmInfo.tasks.completed++;
+                                    completedTasks++;
+                                }
+                                else if (value.status === 'failed') {
+                                    swarmInfo.tasks.failed++;
+                                }
+                                else if (value.status === 'pending' || value.status === 'in_progress') {
+                                    swarmInfo.tasks.pending++;
+                                }
+                            }
+                            // Track last activity
+                            if (record.timestamp > (swarmInfo.lastActivity || 0)) {
+                                swarmInfo.lastActivity = record.timestamp;
+                            }
+                        }
+                        catch (e) {
+                            // Skip invalid JSON values
+                        }
+                    }
+                    // Determine swarm status based on activity
+                    if (swarmInfo.status === 'unknown') {
+                        const now = Date.now();
+                        const lastActivityAge = now - (swarmInfo.lastActivity || 0);
+                        if (lastActivityAge < 60000) { // Active within last minute
+                            swarmInfo.status = 'active';
+                        }
+                        else if (lastActivityAge < 300000) { // Active within last 5 minutes
+                            swarmInfo.status = 'idle';
+                        }
+                        else {
+                            swarmInfo.status = 'inactive';
+                        }
+                    }
+                    swarms.push(swarmInfo);
+                }
+                // Get recent activity logs
+                const activityQuery = this.memoryDb.prepare(`
+          SELECT namespace, key, type, timestamp FROM memories 
+          WHERE (namespace LIKE 'swarm-%' OR namespace LIKE 'hive-%')
+          AND timestamp > ?
+          ORDER BY timestamp DESC
+          LIMIT 10
+        `);
+                const recentActivity = activityQuery.all(Date.now() - 300000); // Last 5 minutes
+                return {
+                    swarms,
+                    activeAgents,
+                    totalTasks,
+                    completedTasks,
+                    pendingTasks: totalTasks - completedTasks,
+                    recentActivity: recentActivity.map(r => ({
+                        swarmId: r.namespace,
+                        action: r.key,
+                        type: r.type,
+                        timestamp: r.timestamp
+                    })),
+                    summary: {
+                        totalSwarms: swarms.length,
+                        activeSwarms: swarms.filter(s => s.status === 'active').length,
+                        idleSwarms: swarms.filter(s => s.status === 'idle').length,
+                        inactiveSwarms: swarms.filter(s => s.status === 'inactive').length
+                    }
+                };
+            }
+            else {
+                // Fallback to in-memory storage
+                const swarmMap = new Map();
+                for (const [key, memory] of this.memoryStore) {
+                    const namespace = memory.namespace;
+                    if (namespace && (namespace.startsWith('swarm-') || namespace.startsWith('hive-'))) {
+                        if (!swarmMap.has(namespace)) {
+                            swarmMap.set(namespace, {
+                                id: namespace,
+                                name: namespace,
+                                status: 'active',
+                                agents: 0,
+                                tasks: { total: 0, completed: 0, pending: 0, failed: 0 },
+                                memoryUsage: 0
+                            });
+                        }
+                        const swarm = swarmMap.get(namespace);
+                        swarm.memoryUsage++;
+                        if (memory.key.startsWith('agent-')) {
+                            swarm.agents++;
+                            activeAgents++;
+                        }
+                        if (memory.key.startsWith('task-')) {
+                            swarm.tasks.total++;
+                            totalTasks++;
+                            try {
+                                const taskData = JSON.parse(memory.value);
+                                if (taskData.status === 'completed') {
+                                    swarm.tasks.completed++;
+                                    completedTasks++;
+                                }
+                            }
+                            catch (e) {
+                                // Skip invalid JSON
+                            }
+                        }
+                    }
+                }
+                return {
+                    swarms: Array.from(swarmMap.values()),
+                    activeAgents,
+                    totalTasks,
+                    completedTasks,
+                    pendingTasks: totalTasks - completedTasks,
+                    summary: {
+                        totalSwarms: swarmMap.size,
+                        activeSwarms: swarmMap.size
+                    }
+                };
+            }
+        }
+        catch (error) {
+            console.error('Error getting swarm status:', error);
+            // Return empty status on error
+            return {
+                swarms: [],
+                activeAgents: 0,
+                totalTasks: 0,
+                completedTasks: 0,
+                pendingTasks: 0,
+                recentActivity: [],
+                summary: {
+                    totalSwarms: 0,
+                    activeSwarms: 0,
+                    idleSwarms: 0,
+                    inactiveSwarms: 0
+                },
+                error: error.message
+            };
+        }
+    }
 }
 // Export tool categories for reference
 export { MCP_TOOLS };