claude-flow 2.0.0-alpha.2 → 2.0.0-alpha.21

package/src/cli/simple-commands/hive-mind.js

@@ -12,6 +12,7 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
 import { args, cwd, exit, writeTextFile, readTextFile, mkdirAsync } from '../node-compat.js';
+import { isInteractive, isRawModeSupported, warnNonInteractive, checkNonInteractiveAuth } from '../utils/interactive-detector.js';
 
 // Import SQLite for persistence
 import Database from 'better-sqlite3';
@@ -84,7 +85,8 @@ ${chalk.bold('OPTIONS:')}
   --spawn                Alias for --claude
   --auto-spawn           Automatically spawn Claude Code instances
   --execute              Execute Claude Code spawn commands immediately
-  --multiple-instances   Spawn one Claude Code instance per worker type (default: single unified instance)
+  --auto                 (Deprecated: auto-permissions enabled by default)
+  --no-auto-permissions  Disable automatic --dangerously-skip-permissions
 
 ${chalk.bold('For more information:')}
 ${chalk.blue('https://github.com/ruvnet/claude-code-flow/docs/hive-mind.md')}
@@ -363,27 +365,115 @@ async function spawnSwarm(args, flags) {
   const spinner = ora('Spawning Hive Mind swarm...').start();
   
   try {
-    // Initialize hive mind core
-    const hiveMind = new HiveMindCore({
-      objective,
-      name: flags.name || `hive-${Date.now()}`,
-      queenType: flags.queenType || 'strategic',
-      maxWorkers: flags.maxWorkers || 8,
-      consensusAlgorithm: flags.consensus || 'majority',
-      autoScale: flags.autoScale !== false,
-      encryption: flags.encryption || false
-    });
+    // Initialize hive mind core with error handling
+    let hiveMind;
+    try {
+      spinner.text = 'Initializing Hive Mind Core...';
+      hiveMind = new HiveMindCore({
+        objective,
+        name: flags.name || `hive-${Date.now()}`,
+        queenType: flags.queenType || 'strategic',
+        maxWorkers: flags.maxWorkers || 8,
+        consensusAlgorithm: flags.consensus || 'majority',
+        autoScale: flags.autoScale !== false,
+        encryption: flags.encryption || false
+      });
+    } catch (error) {
+      console.error('HiveMindCore initialization failed:', error);
+      throw new Error(`Failed to initialize HiveMindCore: ${error.message}`);
+    }
     
+    spinner.text = 'Setting up database connection...';
     // Initialize database connection
-    const dbPath = path.join(cwd(), '.hive-mind', 'hive.db');
-    const db = new Database(dbPath);
+    const dbDir = path.join(cwd(), '.hive-mind');
+    const dbPath = path.join(dbDir, 'hive.db');
     
-    // Create swarm record
-    const swarmId = `swarm-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-    db.prepare(`
-      INSERT INTO swarms (id, name, objective, queen_type)
-      VALUES (?, ?, ?, ?)
-    `).run(swarmId, hiveMind.config.name, objective, hiveMind.config.queenType);
+    // Ensure .hive-mind directory exists
+    if (!existsSync(dbDir)) {
+      mkdirSync(dbDir, { recursive: true });
+    }
+    
+    // Check if database file exists and try to create a clean one if needed
+    let db;
+    try {
+      spinner.text = 'Creating database connection...';
+      db = new Database(dbPath);
+      // Test the database with a simple query
+      db.prepare('SELECT 1').get();
+      spinner.text = 'Database connection established';
+    } catch (error) {
+      console.warn('Database issue detected, recreating...', error.message);
+      spinner.text = 'Recreating database...';
+      // Remove corrupted database
+      if (existsSync(dbPath)) {
+        try {
+          const fs = await import('fs');
+          fs.unlinkSync(dbPath);
+        } catch (e) {
+          console.warn('Could not remove corrupted database:', e.message);
+        }
+      }
+      // Create new database
+      db = new Database(dbPath);
+    }
+    
+    // Initialize database schema if not exists
+    spinner.text = 'Creating database schema...';
+    try {
+      db.exec(`
+      CREATE TABLE IF NOT EXISTS swarms (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        objective TEXT,
+        queen_type TEXT,
+        status TEXT DEFAULT 'active',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+      
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        swarm_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL,
+        role TEXT NOT NULL,
+        status TEXT DEFAULT 'idle',
+        capabilities TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (swarm_id) REFERENCES swarms(id)
+      );
+      
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        swarm_id TEXT NOT NULL,
+        agent_id TEXT,
+        description TEXT,
+        status TEXT DEFAULT 'pending',
+        result TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (swarm_id) REFERENCES swarms(id),
+        FOREIGN KEY (agent_id) REFERENCES agents(id)
+      );
+    `);
+      spinner.text = 'Database schema created successfully';
+    } catch (error) {
+      console.error('Database schema creation failed:', error);
+      throw new Error(`Failed to create database schema: ${error.message}`);
+    }
+    
+    // Create swarm record with safe ID generation
+    spinner.text = 'Creating swarm record...';
+    const timestamp = Date.now();
+    const randomPart = Math.random().toString(36).substring(2, 11); // Use substring instead of substr
+    const swarmId = `swarm-${timestamp}-${randomPart}`;
+    try {
+      db.prepare(`
+        INSERT INTO swarms (id, name, objective, queen_type)
+        VALUES (?, ?, ?, ?)
+      `).run(swarmId, hiveMind.config.name, objective, hiveMind.config.queenType);
+    } catch (error) {
+      console.error('Failed to create swarm record:', error);
+      throw new Error(`Failed to create swarm record: ${error.message}`);
+    }
     
     spinner.text = 'Initializing Queen coordinator...';
     
@@ -500,6 +590,19 @@ async function spawnSwarm(args, flags) {
   } catch (error) {
     spinner.fail('Failed to spawn Hive Mind swarm');
     console.error(chalk.red('Error:'), error.message);
+    
+    // If error contains "sha3", provide specific guidance
+    if (error.message.includes('sha3') || error.message.includes('SHA3')) {
+      console.error('\n🔍 SHA3 Function Error Detected');
+      console.error('This appears to be a SQLite extension or better-sqlite3 configuration issue.');
+      console.error('\nPossible solutions:');
+      console.error('1. Try removing the corrupted database: rm -rf .hive-mind/');
+      console.error('2. Reinstall better-sqlite3: npm reinstall better-sqlite3');
+      console.error('3. Check if any SQLite extensions are conflicting');
+      console.error('\n🚨 Detailed error:');
+      console.error(error.stack || error.message);
+    }
+    
     exit(1);
   }
 }
@@ -964,6 +1067,11 @@ export async function hiveMindCommand(args, flags) {
     return;
   }
   
+  // Warn about non-interactive environments for certain commands
+  if ((subcommand === 'spawn' && (flags.claude || flags.spawn)) || subcommand === 'wizard') {
+    warnNonInteractive('hive-mind ' + subcommand);
+  }
+  
   switch (subcommand) {
     case 'init':
       await initHiveMind(flags);
@@ -1343,134 +1451,103 @@ async function exportMemoryBackup() {
 }
 
 /**
- * Spawn Claude Code instances with detailed MCP tool coordination instructions
+ * Spawn Claude Code with Hive Mind coordination instructions
  */
 async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers, flags) {
-  console.log('\n' + chalk.bold('🚀 Spawning Claude Code Instances'));
+  console.log('\n' + chalk.bold('🚀 Launching Claude Code with Hive Mind Coordination'));
   console.log(chalk.gray('─'.repeat(60)));
   
-  const spinner = ora('Preparing Claude Code coordination instructions...').start();
+  const spinner = ora('Preparing Hive Mind coordination prompt...').start();
   
   try {
-    // Generate detailed coordination instructions
-    const coordinationInstructions = generateCoordinationInstructions(swarmId, swarmName, objective, workers);
-    
-    spinner.text = 'Creating Claude Code spawn commands...';
-    
-    // Create spawn commands for each worker type or single unified instance
-    const spawnCommands = [];
+    // Generate comprehensive Hive Mind prompt
     const workerGroups = groupWorkersByType(workers);
+    const hiveMindPrompt = generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags);
     
-    if (flags.multipleInstances || flags['multiple-instances']) {
-      // Create individual commands for each worker type
-      for (const [workerType, typeWorkers] of Object.entries(workerGroups)) {
-        const spawnCommand = createClaudeCodeSpawnCommand(swarmId, swarmName, objective, workerType, typeWorkers, coordinationInstructions);
-        spawnCommands.push(spawnCommand);
-      }
-    } else {
-      // Default: Create single unified command for all worker types
-      const allWorkerTypes = Object.keys(workerGroups);
-      const spawnCommand = createUnifiedClaudeCodeSpawnCommand(swarmId, swarmName, objective, allWorkerTypes, workers, coordinationInstructions);
-      spawnCommands.push(spawnCommand);
-    }
-    
-    spinner.succeed('Claude Code coordination prepared!');
+    spinner.succeed('Hive Mind coordination prompt ready!');
     
-    // Display coordination details
-    console.log('\n' + chalk.bold('🧠 Hive Mind + Claude Code Coordination'));
+    // Display coordination summary
+    console.log('\n' + chalk.bold('🧠 Hive Mind Configuration'));
     console.log(chalk.gray('─'.repeat(60)));
     console.log(chalk.cyan('Swarm ID:'), swarmId);
     console.log(chalk.cyan('Objective:'), objective);
+    console.log(chalk.cyan('Queen Type:'), flags.queenType || 'strategic');
+    console.log(chalk.cyan('Worker Count:'), workers.length);
     console.log(chalk.cyan('Worker Types:'), Object.keys(workerGroups).join(', '));
-    console.log(chalk.cyan('MCP Tools:'), 'Full ruv-swarm integration enabled');
-    console.log(chalk.cyan('Coordination:'), 'Hive Mind collective intelligence');
-    
-    // Show spawn commands
-    console.log('\n' + chalk.bold('📋 Claude Code Spawn Commands'));
-    console.log(chalk.gray('─'.repeat(60)));
-    
-    spawnCommands.forEach((command, index) => {
-      console.log(chalk.yellow(`\n${index + 1}. ${command.title}`));
-      console.log(chalk.gray('   Command:'));
-      console.log(chalk.green(`   claude "[comprehensive hive-mind coordination prompt]" --dangerously-skip-permissions`));
-      console.log(chalk.gray(`   Prompt Length: ${command.context.length} characters`));
-      console.log(chalk.gray('   Includes: BatchTool guidance, agent spawning patterns, coordination protocols'));
-      
-      if (flags.verbose) {
-        console.log(chalk.gray('   Full Command:'));
-        console.log(chalk.blue(`   ${command.command}`));
-      }
-    });
+    console.log(chalk.cyan('Consensus Algorithm:'), flags.consensus || 'majority');
+    console.log(chalk.cyan('MCP Tools:'), 'Full Claude-Flow integration enabled');
     
-    // Spawn Claude Code instances when requested
-    if (flags.claude || flags.spawn || flags.autoSpawn || flags.execute) {
-      console.log('\n' + chalk.yellow('🚀 Spawning Claude Code instances...'));
-      
-      const { spawn: childSpawn, execSync } = await import('child_process');
-      
+    try {
       // Check if claude command exists
+      const { spawn: childSpawn, execSync } = await import('child_process');
       let claudeAvailable = false;
+      
       try {
         execSync('which claude', { stdio: 'ignore' });
         claudeAvailable = true;
       } catch {
         console.log(chalk.yellow('\n⚠️  Claude Code CLI not found in PATH'));
         console.log(chalk.gray('Install it with: npm install -g @anthropic/claude-code-cli'));
+        console.log(chalk.gray('\nFalling back to displaying instructions...'));
       }
       
-      for (const command of spawnCommands) {
-        console.log(chalk.gray(`\nSpawning: ${command.title}`));
+      
+      if (claudeAvailable && !flags.dryRun) {
+        // Pass the prompt directly as an argument to claude
+        const claudeArgs = [hiveMindPrompt];
         
-        if (!claudeAvailable && !flags.dryRun) {
-          console.log(chalk.blue('Command to run manually:'));
-          console.log(chalk.green(`  ${command.command}`));
-          continue;
+        // Add auto-permission flag by default for hive-mind mode (unless explicitly disabled)
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+          claudeArgs.push('--dangerously-skip-permissions');
+          console.log(chalk.yellow('🔓 Using --dangerously-skip-permissions by default for seamless hive-mind execution'));
         }
         
-        if (flags.dryRun) {
-          console.log(chalk.blue('Dry run - would execute:'));
-          console.log(chalk.green(`  ${command.command}`));
-          console.log(chalk.gray('Context length:'), command.context.length, 'characters');
-          continue;
-        }
+        // Spawn claude with the prompt as the first argument
+        const claudeProcess = childSpawn('claude', claudeArgs, {
+          stdio: 'inherit',
+          shell: false
+        });
         
-        try {
-          // Create Claude args with direct prompt injection and auto-permissions
-          const claudeArgs = [command.context, '--dangerously-skip-permissions'];
-          
-          // Spawn claude process
-          const claudeProcess = childSpawn('claude', claudeArgs, {
-            stdio: 'inherit',
-            shell: false
-          });
-          
-          console.log(chalk.green('✓ Claude Code instance spawned for'), command.title);
-          console.log(chalk.blue('  Context provided with MCP tool coordination instructions'));
-          
-          // Don't wait for completion - let them run in parallel
-        } catch (error) {
-          console.error(chalk.red(`Failed to spawn Claude Code for ${command.title}:`), error.message);
-        }
+        console.log(chalk.green('\n✓ Claude Code launched with Hive Mind coordination'));
+        console.log(chalk.blue('  The Queen coordinator will orchestrate all worker agents'));
+        console.log(chalk.blue('  Use MCP tools for collective intelligence and task distribution'));
+        
+      } else if (flags.dryRun) {
+        console.log(chalk.blue('\nDry run - would execute Claude Code with prompt:'));
+        console.log(chalk.gray('Prompt length:'), hiveMindPrompt.length, 'characters');
+        console.log(chalk.gray('\nFirst 500 characters of prompt:'));
+        console.log(chalk.yellow(hiveMindPrompt.substring(0, 500) + '...'));
+        
+        // Save prompt to file for inspection
+        const promptFile = `hive-mind-prompt-${swarmId}.txt`;
+        await writeFile(promptFile, hiveMindPrompt, 'utf8');
+        console.log(chalk.green(`\n✓ Full prompt saved to: ${promptFile}`));
+        
+      } else {
+        // Claude not available - save prompt and show instructions
+        const promptFile = `hive-mind-prompt-${swarmId}.txt`;
+        await writeFile(promptFile, hiveMindPrompt, 'utf8');
+        
+        console.log(chalk.yellow('\n📋 Manual Execution Instructions:'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.gray('1. Install Claude Code:'));
+        console.log(chalk.green('   npm install -g @anthropic/claude-code-cli'));
+        console.log(chalk.gray('\n2. Run with the saved prompt:'));
+        console.log(chalk.green(`   claude < ${promptFile}`));
+        console.log(chalk.gray('\n3. Or copy the prompt manually:'));
+        console.log(chalk.green(`   cat ${promptFile} | claude`));
+        console.log(chalk.gray('\n4. With auto-permissions:'));
+        console.log(chalk.green(`   claude --dangerously-skip-permissions < ${promptFile}`));
       }
       
-      console.log('\n' + chalk.bold.green('🎉 All Claude Code instances spawned and coordinated!'));
-      console.log(chalk.gray('Instances are running with Hive Mind coordination protocols.'));
-    } else {
-      // Provide coordination instructions
-      console.log('\n' + chalk.bold('🎯 Next Steps:'));
-      console.log(chalk.gray('─'.repeat(40)));
-      console.log('1. Copy and execute the spawn commands above');
-      console.log('2. Each Claude Code instance will have full MCP tool access');
-      console.log('3. Use ruv-swarm tools for coordination between instances');
-      console.log('4. Monitor progress with: claude-flow hive-mind status');
+    } catch (error) {
+      console.error(chalk.red('\nFailed to launch Claude Code:'), error.message);
       
-      console.log('\n' + chalk.bold('🔧 Available MCP Tools for Coordination:'));
-      console.log(chalk.gray('─'.repeat(50)));
-      console.log(chalk.cyan('• mcp__ruv-swarm__memory_usage') + ' - Share knowledge between instances');
-      console.log(chalk.cyan('• mcp__ruv-swarm__swarm_monitor') + ' - Real-time coordination tracking');
-      console.log(chalk.cyan('• mcp__ruv-swarm__task_orchestrate') + ' - Distribute work efficiently');
-      console.log(chalk.cyan('• mcp__ruv-swarm__neural_train') + ' - Learn from coordination patterns');
-      console.log(chalk.cyan('• mcp__ruv-swarm__consensus_vote') + ' - Make collective decisions');
+      // Save prompt as fallback
+      const promptFile = `hive-mind-prompt-${swarmId}-fallback.txt`;
+      await writeFile(promptFile, hiveMindPrompt, 'utf8');
+      console.log(chalk.green(`\n✓ Prompt saved to: ${promptFile}`));
+      console.log(chalk.yellow('\nYou can run Claude Code manually with the saved prompt'));
     }
     
     console.log('\n' + chalk.bold('💡 Pro Tips:'));
@@ -1486,6 +1563,164 @@ async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers,
   }
 }
 
+/**
+ * Generate comprehensive Hive Mind prompt for Claude Code
+ */
+function generateHiveMindPrompt(swarmId, swarmName, objective, workers, workerGroups, flags) {
+  const currentTime = new Date().toISOString();
+  const workerTypes = Object.keys(workerGroups);
+  const queenType = flags.queenType || 'strategic';
+  const consensusAlgorithm = flags.consensus || 'majority';
+  
+  return `🧠 HIVE MIND COLLECTIVE INTELLIGENCE SYSTEM
+═══════════════════════════════════════════════
+
+You are the Queen coordinator of a Hive Mind swarm with collective intelligence capabilities.
+
+HIVE MIND CONFIGURATION:
+📌 Swarm ID: ${swarmId}
+📌 Swarm Name: ${swarmName}
+🎯 Objective: ${objective}
+👑 Queen Type: ${queenType}
+🐝 Worker Count: ${workers.length}
+🤝 Consensus Algorithm: ${consensusAlgorithm}
+⏰ Initialized: ${currentTime}
+
+WORKER DISTRIBUTION:
+${workerTypes.map(type => `• ${type}: ${workerGroups[type].length} agents`).join('\n')}
+
+🔧 AVAILABLE MCP TOOLS FOR HIVE MIND COORDINATION:
+
+1️⃣ **COLLECTIVE INTELLIGENCE**
+   mcp__claude-flow__consensus_vote    - Democratic decision making
+   mcp__claude-flow__memory_share      - Share knowledge across the hive
+   mcp__claude-flow__neural_sync       - Synchronize neural patterns
+   mcp__claude-flow__swarm_think       - Collective problem solving
+
+2️⃣ **QUEEN COORDINATION**
+   mcp__claude-flow__queen_command     - Issue directives to workers
+   mcp__claude-flow__queen_monitor     - Monitor swarm health
+   mcp__claude-flow__queen_delegate    - Delegate complex tasks
+   mcp__claude-flow__queen_aggregate   - Aggregate worker results
+
+3️⃣ **WORKER MANAGEMENT**
+   mcp__claude-flow__agent_spawn       - Create specialized workers
+   mcp__claude-flow__agent_assign      - Assign tasks to workers
+   mcp__claude-flow__agent_communicate - Inter-agent communication
+   mcp__claude-flow__agent_metrics     - Track worker performance
+
+4️⃣ **TASK ORCHESTRATION**
+   mcp__claude-flow__task_create       - Create hierarchical tasks
+   mcp__claude-flow__task_distribute   - Distribute work efficiently
+   mcp__claude-flow__task_monitor      - Track task progress
+   mcp__claude-flow__task_aggregate    - Combine task results
+
+5️⃣ **MEMORY & LEARNING**
+   mcp__claude-flow__memory_store      - Store collective knowledge
+   mcp__claude-flow__memory_retrieve   - Access shared memory
+   mcp__claude-flow__neural_train      - Learn from experiences
+   mcp__claude-flow__pattern_recognize - Identify patterns
+
+📋 HIVE MIND EXECUTION PROTOCOL:
+
+As the Queen coordinator, you must:
+
+1. **INITIALIZE THE HIVE** (Single BatchTool Message):
+   [BatchTool]:
+   ${workerTypes.map(type => `   mcp__claude-flow__agent_spawn { "type": "${type}", "count": ${workerGroups[type].length} }`).join('\n')}
+   mcp__claude-flow__memory_store { "key": "hive/objective", "value": "${objective}" }
+   mcp__claude-flow__memory_store { "key": "hive/queen", "value": "${queenType}" }
+   mcp__claude-flow__swarm_think { "topic": "initial_strategy" }
+   TodoWrite { "todos": [/* Create 5-10 high-level tasks */] }
+
+2. **ESTABLISH COLLECTIVE INTELLIGENCE**:
+   - Use consensus_vote for major decisions
+   - Share all discoveries via memory_share
+   - Synchronize learning with neural_sync
+   - Coordinate strategy with swarm_think
+
+3. **QUEEN LEADERSHIP PATTERNS**:
+   ${queenType === 'strategic' ? `
+   - Focus on high-level planning and coordination
+   - Delegate implementation details to workers
+   - Monitor overall progress and adjust strategy
+   - Make executive decisions when consensus fails` : ''}
+   ${queenType === 'tactical' ? `
+   - Manage detailed task breakdowns and assignments
+   - Closely monitor worker progress and efficiency
+   - Optimize resource allocation and load balancing
+   - Intervene directly when workers need guidance` : ''}
+   ${queenType === 'adaptive' ? `
+   - Learn from swarm performance and adapt strategies
+   - Experiment with different coordination patterns
+   - Use neural training to improve over time
+   - Balance between strategic and tactical approaches` : ''}
+
+4. **WORKER COORDINATION**:
+   - Spawn workers based on task requirements
+   - Assign tasks according to worker specializations
+   - Enable peer-to-peer communication for collaboration
+   - Monitor and rebalance workloads as needed
+
+5. **CONSENSUS MECHANISMS**:
+   ${consensusAlgorithm === 'majority' ? '- Decisions require >50% worker agreement' : ''}
+   ${consensusAlgorithm === 'unanimous' ? '- All workers must agree for major decisions' : ''}
+   ${consensusAlgorithm === 'weighted' ? '- Worker votes weighted by expertise and performance' : ''}
+   ${consensusAlgorithm === 'quorum' ? '- Decisions require 2/3 worker participation' : ''}
+
+6. **COLLECTIVE MEMORY**:
+   - Store all important decisions in shared memory
+   - Tag memories with worker IDs and timestamps
+   - Use memory namespaces: hive/, queen/, workers/, tasks/
+   - Implement memory consensus for critical data
+
+7. **PERFORMANCE OPTIMIZATION**:
+   - Monitor swarm metrics continuously
+   - Identify and resolve bottlenecks
+   - Train neural networks on successful patterns
+   - Scale worker count based on workload
+
+💡 HIVE MIND BEST PRACTICES:
+
+✅ ALWAYS use BatchTool for parallel operations
+✅ Store decisions in collective memory immediately
+✅ Use consensus for critical path decisions
+✅ Monitor worker health and reassign if needed
+✅ Learn from failures and adapt strategies
+✅ Maintain constant inter-agent communication
+✅ Aggregate results before final delivery
+
+❌ NEVER make unilateral decisions without consensus
+❌ NEVER let workers operate in isolation
+❌ NEVER ignore performance metrics
+❌ NEVER skip memory synchronization
+❌ NEVER abandon failing workers
+
+🎯 OBJECTIVE EXECUTION STRATEGY:
+
+For the objective: "${objective}"
+
+1. Break down into major phases using swarm_think
+2. Create specialized worker teams for each phase
+3. Establish success criteria and checkpoints
+4. Implement feedback loops and adaptation
+5. Aggregate and synthesize all worker outputs
+6. Deliver comprehensive solution with consensus
+
+⚡ PARALLEL EXECUTION REMINDER:
+The Hive Mind operates with massive parallelism. Always batch operations:
+- Spawn ALL workers in one message
+- Create ALL initial tasks together
+- Store multiple memories simultaneously
+- Check all statuses in parallel
+
+🚀 BEGIN HIVE MIND EXECUTION:
+
+Initialize the swarm now with the configuration above. Use your collective intelligence to solve the objective efficiently. The Queen must coordinate, workers must collaborate, and the hive must think as one.
+
+Remember: You are not just coordinating agents - you are orchestrating a collective intelligence that is greater than the sum of its parts.`;
+}
+
 /**
  * Generate comprehensive coordination instructions for Claude Code instances
  */
@@ -1535,259 +1770,47 @@ function groupWorkersByType(workers) {
  * Create Claude Code spawn command with coordination context
  */
 function createClaudeCodeSpawnCommand(swarmId, swarmName, objective, workerType, typeWorkers, instructions) {
-  const context = `🎯 MISSION: ${objective}
-
-You are a ${workerType.toUpperCase()} agent in the "${swarmName}" Hive Mind swarm.
-
-🐝 SWARM CONFIGURATION:
-────────────────────────────────────────────────────────────
-Swarm: ${swarmName} (${swarmId})
-Your Role: ${workerType.toUpperCase()} specialist
-Team: ${typeWorkers.length} ${workerType}(s) | Queen: strategic | Consensus: majority
-MCP Tools: Full ruv-swarm integration enabled
-────────────────────────────────────────────────────────────
-
-🚨 CRITICAL: MANDATORY PARALLEL EXECUTION & BATCH OPERATIONS
-
-### 🔴 GOLDEN RULE: BATCH EVERYTHING - NEVER SEQUENTIAL
-
-**If you need to do X operations, they should be in 1 message, not X messages**
-
-### ⚡ PARALLEL EXECUTION IS MANDATORY
-
-**❌ WRONG - Sequential (NEVER DO THIS):**
-\`\`\`
-Message 1: mcp__ruv-swarm__memory_usage (single operation)
-Message 2: mcp__ruv-swarm__swarm_status (single operation)
-Message 3: Write file1.js
-Message 4: Write file2.js
-Message 5: TodoWrite (single todo)
-// This is 5x slower and breaks coordination!
-\`\`\`
-
-**✅ CORRECT - Parallel (ALWAYS DO THIS):**
-\`\`\`
-Message 1: [BatchTool - ALL operations at once]
-  - mcp__ruv-swarm__memory_usage (retrieve context)
-  - mcp__ruv-swarm__swarm_status (check swarm state)
-  - mcp__ruv-swarm__task_orchestrate (coordinate tasks)
-  - Write file1.js
-  - Write file2.js
-  - Write file3.js
-  - TodoWrite (multiple todos at once)
-  - Bash commands (multiple mkdir/npm commands)
-\`\`\`
-
-### 🤖 AGENT SPAWNING WITH BATCHTOOL
-
-**CRITICAL: When you need multiple agents, spawn them ALL in parallel using BatchTool:**
-
-**❌ WRONG - Sequential Agent Spawning:**
-\`\`\`
-Message 1: mcp__ruv-swarm__agent_spawn (researcher)
-Message 2: mcp__ruv-swarm__agent_spawn (coder)
-Message 3: mcp__ruv-swarm__agent_spawn (analyst)
-Message 4: mcp__ruv-swarm__agent_spawn (tester)
-// This creates coordination delays and inefficiency!
-\`\`\`
-
-**✅ CORRECT - Parallel Agent Spawning:**
-\`\`\`
-Message 1: [BatchTool - Spawn ALL agents at once]
-  - mcp__ruv-swarm__swarm_init {"topology": "hierarchical", "maxAgents": 8, "strategy": "parallel"}
-  - mcp__ruv-swarm__agent_spawn {"type": "researcher", "name": "Research Lead", "capabilities": ["web_search", "analysis"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Backend Dev", "capabilities": ["nodejs", "apis", "databases"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Frontend Dev", "capabilities": ["react", "ui", "testing"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "analyst", "name": "System Architect", "capabilities": ["design", "patterns", "scalability"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "tester", "name": "QA Engineer", "capabilities": ["testing", "automation", "ci_cd"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coordinator", "name": "Project Manager", "capabilities": ["coordination", "monitoring"]}
-  - TodoWrite {"todos": [{"id": "init", "content": "Initialize swarm coordination", "status": "in_progress", "priority": "high"}]}
-\`\`\`
-
-### 🚀 SWARM INITIALIZATION PATTERN
-
-**MANDATORY: Always start with full swarm initialization in ONE message:**
-\`\`\`
-[BatchTool - Complete Swarm Setup]:
-  - mcp__ruv-swarm__swarm_init {"topology": "mesh", "maxAgents": 10, "strategy": "adaptive"}
-  - mcp__ruv-swarm__agent_spawn {"type": "architect", "name": "System Designer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "researcher", "name": "Tech Research"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "API Developer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Service Developer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "analyst", "name": "Performance Analyst"}
-  - mcp__ruv-swarm__agent_spawn {"type": "tester", "name": "Integration Tester"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coordinator", "name": "DevOps Lead"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "swarm/init", "value": {"objective": "${objective}", "started": "timestamp"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "strategy": "parallel", "priority": "high"}
-  - TodoWrite {"todos": [multiple initialization todos]}
-\`\`\`
-
-### 🔄 CONTINUOUS COORDINATION PATTERN
-
-**After spawning agents, coordinate them in batches:**
-\`\`\`
-[BatchTool - Agent Coordination]:
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "distribute": "evenly"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "coordination/status", "value": {"active_agents": "count"}}
-  - mcp__ruv-swarm__swarm_monitor {"swarmId": "${swarmId}", "track": "all_agents"}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "pattern": "parallel_coordination"}
-\`\`\`
-
-### 📦 MANDATORY BATCH PATTERNS
-
-**MCP Tool Coordination (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/context"}
-  - mcp__ruv-swarm__swarm_status {"swarmId": "${swarmId}"}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "strategy": "parallel"}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "pattern": "batch_coordination"}
-\`\`\`
-
-**File Operations (Single Message):**
-\`\`\`
-[BatchTool]:
-  - Read package.json
-  - Read README.md
-  - Read config.json
-  - Write src/index.js
-  - Write src/utils.js
-  - Write tests/test.js
-  - MultiEdit src/main.js (multiple edits)
-\`\`\`
-
-**Command Operations (Single Message):**
-\`\`\`
-[BatchTool]:
-  - Bash "mkdir -p src/{components,utils,tests}"
-  - Bash "npm install --save express"
-  - Bash "npm run test"
-  - Bash "npm run lint"
-  - Bash "git add -A"
-\`\`\`
-
-### 🎯 MANDATORY COORDINATION PROTOCOL
-
-**1️⃣ BEFORE Starting Work (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/status"}
-  - mcp__ruv-swarm__swarm_status {"swarmId": "${swarmId}"}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "action": "join"}
-  - TodoWrite {"todos": [all initial todos at once]}
-\`\`\`
-
-**2️⃣ DURING Work (After EVERY Major Step - Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/${workerType}/progress", "value": {"step": "X", "status": "Y", "findings": "Z"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "update": {"agentId": "your-id", "progress": "details"}}
-  - mcp__ruv-swarm__swarm_monitor {"swarmId": "${swarmId}", "checkCoordination": true}
-  - TodoWrite {"todos": [updated todos with progress]}
-\`\`\`
-
-**3️⃣ FOR Decisions (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/decisions"}
-  - mcp__ruv-swarm__consensus_vote {"swarmId": "${swarmId}", "topic": "decision topic", "vote": "your choice", "rationale": "reasoning"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/decisions/latest", "value": {"decision": "what", "rationale": "why"}}
-\`\`\`
-
-**4️⃣ WHEN Sharing Insights (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/insights/${workerType}", "value": {"insight": "your discovery", "impact": "significance"}}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "experience": {"pattern": "insight_sharing", "outcome": "result"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "broadcast": {"type": "insight", "data": "summary"}}
-\`\`\`
-
-**5️⃣ BEFORE Completing Work (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/${workerType}/final", "value": {"completed": "work summary", "learnings": "key insights"}}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "experience": {"what": "learned", "outcome": "result"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "complete": {"agentId": "your-id", "summary": "work done"}}
-  - TodoWrite {"todos": [mark all relevant todos as completed]}
-\`\`\`
-
-### 🔧 SPECIALIZED CAPABILITIES:
+  const context = `You are a ${workerType} agent in the "${swarmName}" Hive Mind swarm.
+
+🎯 MISSION: ${objective}
+
+🐝 SWARM COORDINATION:
+- Swarm ID: ${swarmId}
+- Your Role: ${workerType.toUpperCase()} specialist
+- Team Size: ${typeWorkers.length} ${workerType}(s)
+- Coordination: Hive Mind collective intelligence
+
+🧠 MANDATORY COORDINATION PROTOCOL:
+1. BEFORE starting work:
+   mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/status"}
+   mcp__ruv-swarm__swarm_status {"swarmId": "${swarmId}"}
+
+2. DURING work (after each major step):
+   mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/${workerType}/progress", "value": {"step": "X", "status": "Y", "findings": "Z"}}
+   mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "update": {"agentId": "your-id", "progress": "details"}}
+
+3. FOR decisions requiring consensus:
+   mcp__ruv-swarm__consensus_vote {"swarmId": "${swarmId}", "topic": "decision topic", "vote": "your choice", "rationale": "reasoning"}
+
+4. WHEN sharing insights:
+   mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/insights/${workerType}", "value": {"insight": "your discovery", "impact": "significance"}}
+
+5. BEFORE completing work:
+   mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "experience": {"what": "learned", "outcome": "result"}}
+
+🔧 SPECIALIZED CAPABILITIES:
 ${getWorkerTypeInstructions(workerType)}
 
-### 🚨 PERFORMANCE OPTIMIZATION RULES:
-
-1. **Token Reduction**: Batch operations reduce context switching by 32.3%
-2. **Speed Improvement**: Parallel coordination is 2.8-4.4x faster
-3. **Memory Efficiency**: Shared memory prevents duplicate work
-4. **Coordination Quality**: Batch patterns improve decision consistency
-
-### 📊 VISUAL COORDINATION TRACKING:
-
-Use this format for progress updates:
-\`\`\`
-🐝 Swarm Coordination Status
-├── 🏗️ Agent: ${workerType}
-├── 👥 Swarm: ${swarmName}
-├── ⚡ Mode: parallel batch execution
-├── 📊 Progress: X/Y tasks (Z% complete)
-└── 🧠 Memory: N coordination points stored
-
-Current Activity:
-├── 🟢 Coordination: Active batch operations
-├── 🟡 Memory: Syncing with swarm
-├── 🔄 Tasks: Executing in parallel
-└── 📈 Performance: Optimized for speed
-\`\`\`
-
-### 🤝 MANDATORY COORDINATION RULES:
-
-- **NEVER** operate sequentially when batch operations are possible
-- **ALWAYS** use BatchTool for multiple operations
-- **SHARE** all discoveries via memory_usage in batch
-- **VOTE** on critical decisions using consensus_vote
-- **UPDATE** progress every major step via task_orchestrate
-- **MONITOR** other agents via swarm_status
-- **LEARN** from patterns via neural_train
-- **COORDINATE** through shared memory, not individual messages
-
-### 💡 CRITICAL SUCCESS FACTORS:
-
-1. **Batch First Mindset**: Always think "what can be combined?"
-2. **Parallel Execution**: Never wait for one operation to complete another
-3. **Memory Coordination**: Use shared memory for all cross-agent communication
-4. **Real-time Updates**: Keep swarm informed of progress and decisions
-5. **Pattern Learning**: Train neural patterns from successful coordination
-
-### 🛠️ TOOL USAGE GUIDELINES:
-
-**FOR CODE AND WEB OPERATIONS - Use Claude Code Native Tools:**
-- **Code Tasks**: Use Read, Write, Edit, MultiEdit, Bash tools for all file operations
-- **Web Research**: Use WebSearch and WebFetch for web-based research
-- **File Management**: Use Glob, Grep, LS for file system operations
-- **Command Execution**: Use Bash for all system commands and package management
-
-**FOR COORDINATION - Use MCP Swarm Tools:**
-- **Agent Management**: Use mcp__ruv-swarm__agent_spawn for creating agents
-- **Memory Sharing**: Use mcp__ruv-swarm__memory_usage for cross-agent communication
-- **Task Coordination**: Use mcp__ruv-swarm__task_orchestrate for work distribution
-- **Consensus Building**: Use mcp__ruv-swarm__consensus_vote for decisions
-- **Monitoring**: Use mcp__ruv-swarm__swarm_monitor for progress tracking
-
-**EXAMPLE - Correct Tool Selection:**
-\`\`\`
-[BatchTool - Code Development with Coordination]:
-  - Read package.json                    # Claude Code native
-  - Write src/server.js                  # Claude Code native  
-  - Bash "npm install express"           # Claude Code native
-  - WebSearch "Node.js best practices"   # Claude Code native
-  - mcp__ruv-swarm__memory_usage {...}   # MCP for coordination
-  - mcp__ruv-swarm__agent_spawn {...}    # MCP for coordination
-  - TodoWrite {...}                      # Claude Code native
-\`\`\`
-
-Remember: You are part of a COLLECTIVE INTELLIGENCE with PARALLEL COORDINATION. Your success depends on BATCH OPERATIONS, PROPER TOOL SELECTION, and SWARM SYNCHRONIZATION!`;
-
-  const command = `claude "${context.replace(/"/g, '\\"')}" --dangerously-skip-permissions`;
+🤝 COORDINATION RULES:
+- Share ALL discoveries via memory_usage
+- Vote on critical decisions using consensus_vote
+- Update progress every 15 minutes via task_orchestrate
+- Monitor other agents via swarm_status
+- Learn from patterns via neural_train
+
+Remember: You are part of a COLLECTIVE INTELLIGENCE. Your individual success depends on swarm coordination!`;
+
+  const command = `claude code --context "${context.replace(/"/g, '\\"')}"`;
   
   return {
     title: `${workerType.toUpperCase()} Agent (${typeWorkers.length} instance${typeWorkers.length > 1 ? 's' : ''})`,
@@ -1798,275 +1821,6 @@ Remember: You are part of a COLLECTIVE INTELLIGENCE with PARALLEL COORDINATION.
   };
 }
 
-/**
- * Create unified Claude Code spawn command for all worker types
- */
-function createUnifiedClaudeCodeSpawnCommand(swarmId, swarmName, objective, workerTypes, workers, instructions) {
-  const context = `🎯 MISSION: ${objective}
-
-You are a MULTI-ROLE agent in the "${swarmName}" Hive Mind swarm.
-
-🐝 SWARM CONFIGURATION:
-────────────────────────────────────────────────────────────
-Swarm: ${swarmName} (${swarmId})
-Your Roles: ${workerTypes.map(t => t.toUpperCase()).join(', ')} specialist
-Team: ${workers.length} agents | Queen: strategic | Consensus: majority
-MCP Tools: Full ruv-swarm integration enabled
-────────────────────────────────────────────────────────────
-
-🚨 CRITICAL: MANDATORY PARALLEL EXECUTION & BATCH OPERATIONS
-
-### 🔴 GOLDEN RULE: BATCH EVERYTHING - NEVER SEQUENTIAL
-
-**If you need to do X operations, they should be in 1 message, not X messages**
-
-### ⚡ PARALLEL EXECUTION IS MANDATORY
-
-**❌ WRONG - Sequential (NEVER DO THIS):**
-\`\`\`
-Message 1: mcp__ruv-swarm__memory_usage (single operation)
-Message 2: mcp__ruv-swarm__swarm_status (single operation)
-Message 3: Write file1.js
-Message 4: Write file2.js
-Message 5: TodoWrite (single todo)
-// This is 5x slower and breaks coordination!
-\`\`\`
-
-**✅ CORRECT - Parallel (ALWAYS DO THIS):**
-\`\`\`
-Message 1: [BatchTool - ALL operations at once]
-  - mcp__ruv-swarm__memory_usage (retrieve context)
-  - mcp__ruv-swarm__swarm_status (check swarm state)
-  - mcp__ruv-swarm__task_orchestrate (coordinate tasks)
-  - Write file1.js
-  - Write file2.js
-  - Write file3.js
-  - TodoWrite (multiple todos at once)
-  - Bash commands (multiple mkdir/npm commands)
-\`\`\`
-
-### 🤖 AGENT SPAWNING WITH BATCHTOOL
-
-**CRITICAL: When you need multiple agents, spawn them ALL in parallel using BatchTool:**
-
-**❌ WRONG - Sequential Agent Spawning:**
-\`\`\`
-Message 1: mcp__ruv-swarm__agent_spawn (researcher)
-Message 2: mcp__ruv-swarm__agent_spawn (coder)
-Message 3: mcp__ruv-swarm__agent_spawn (analyst)
-Message 4: mcp__ruv-swarm__agent_spawn (tester)
-// This creates coordination delays and inefficiency!
-\`\`\`
-
-**✅ CORRECT - Parallel Agent Spawning:**
-\`\`\`
-Message 1: [BatchTool - Spawn ALL agents at once]
-  - mcp__ruv-swarm__swarm_init {"topology": "hierarchical", "maxAgents": 8, "strategy": "parallel"}
-  - mcp__ruv-swarm__agent_spawn {"type": "researcher", "name": "Research Lead", "capabilities": ["web_search", "analysis"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Backend Dev", "capabilities": ["nodejs", "apis", "databases"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Frontend Dev", "capabilities": ["react", "ui", "testing"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "analyst", "name": "System Architect", "capabilities": ["design", "patterns", "scalability"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "tester", "name": "QA Engineer", "capabilities": ["testing", "automation", "ci_cd"]}
-  - mcp__ruv-swarm__agent_spawn {"type": "coordinator", "name": "Project Manager", "capabilities": ["coordination", "monitoring"]}
-  - TodoWrite {"todos": [{"id": "init", "content": "Initialize swarm coordination", "status": "in_progress", "priority": "high"}]}
-\`\`\`
-
-### 🚀 SWARM INITIALIZATION PATTERN
-
-**MANDATORY: Always start with full swarm initialization in ONE message:**
-\`\`\`
-[BatchTool - Complete Swarm Setup]:
-  - mcp__ruv-swarm__swarm_init {"topology": "mesh", "maxAgents": 10, "strategy": "adaptive"}
-  - mcp__ruv-swarm__agent_spawn {"type": "architect", "name": "System Designer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "researcher", "name": "Tech Research"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "API Developer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coder", "name": "Service Developer"}
-  - mcp__ruv-swarm__agent_spawn {"type": "analyst", "name": "Performance Analyst"}
-  - mcp__ruv-swarm__agent_spawn {"type": "tester", "name": "Integration Tester"}
-  - mcp__ruv-swarm__agent_spawn {"type": "coordinator", "name": "DevOps Lead"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "swarm/init", "value": {"objective": "${objective}", "started": "timestamp"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "strategy": "parallel", "priority": "high"}
-  - TodoWrite {"todos": [multiple initialization todos]}
-\`\`\`
-
-### 🔄 CONTINUOUS COORDINATION PATTERN
-
-**After spawning agents, coordinate them in batches:**
-\`\`\`
-[BatchTool - Agent Coordination]:
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "distribute": "evenly"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "coordination/status", "value": {"active_agents": "count"}}
-  - mcp__ruv-swarm__swarm_monitor {"swarmId": "${swarmId}", "track": "all_agents"}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "pattern": "parallel_coordination"}
-\`\`\`
-
-### 📦 MANDATORY BATCH PATTERNS
-
-**MCP Tool Coordination (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/context"}
-  - mcp__ruv-swarm__swarm_status {"swarmId": "${swarmId}"}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "strategy": "parallel"}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "pattern": "batch_coordination"}
-\`\`\`
-
-**File Operations (Single Message):**
-\`\`\`
-[BatchTool]:
-  - Read package.json
-  - Read README.md
-  - Read config.json
-  - Write src/index.js
-  - Write src/utils.js
-  - Write tests/test.js
-  - MultiEdit src/main.js (multiple edits)
-\`\`\`
-
-**Command Operations (Single Message):**
-\`\`\`
-[BatchTool]:
-  - Bash "mkdir -p src/{components,utils,tests}"
-  - Bash "npm install --save express"
-  - Bash "npm run test"
-  - Bash "npm run lint"
-  - Bash "git add -A"
-\`\`\`
-
-### 🎯 MANDATORY COORDINATION PROTOCOL
-
-**1️⃣ BEFORE Starting Work (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/status"}
-  - mcp__ruv-swarm__swarm_status {"swarmId": "${swarmId}"}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "action": "join"}
-  - TodoWrite {"todos": [all initial todos at once]}
-\`\`\`
-
-**2️⃣ DURING Work (After EVERY Major Step - Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/multi-role/progress", "value": {"step": "X", "status": "Y", "findings": "Z"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "update": {"agentId": "your-id", "progress": "details"}}
-  - mcp__ruv-swarm__swarm_monitor {"swarmId": "${swarmId}", "checkCoordination": true}
-  - TodoWrite {"todos": [updated todos with progress]}
-\`\`\`
-
-**3️⃣ FOR Decisions (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "retrieve", "key": "hive-mind-${swarmId}/decisions"}
-  - mcp__ruv-swarm__consensus_vote {"swarmId": "${swarmId}", "topic": "decision topic", "vote": "your choice", "rationale": "reasoning"}
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/decisions/latest", "value": {"decision": "what", "rationale": "why"}}
-\`\`\`
-
-**4️⃣ WHEN Sharing Insights (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/insights/multi-role", "value": {"insight": "your discovery", "impact": "significance"}}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "experience": {"pattern": "insight_sharing", "outcome": "result"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "broadcast": {"type": "insight", "data": "summary"}}
-\`\`\`
-
-**5️⃣ BEFORE Completing Work (Single Message):**
-\`\`\`
-[BatchTool]:
-  - mcp__ruv-swarm__memory_usage {"action": "store", "key": "hive-mind-${swarmId}/multi-role/final", "value": {"completed": "work summary", "learnings": "key insights"}}
-  - mcp__ruv-swarm__neural_train {"swarmId": "${swarmId}", "experience": {"what": "learned", "outcome": "result"}}
-  - mcp__ruv-swarm__task_orchestrate {"swarmId": "${swarmId}", "complete": {"agentId": "your-id", "summary": "work done"}}
-  - TodoWrite {"todos": [mark all relevant todos as completed]}
-\`\`\`
-
-### 🔧 MULTI-ROLE CAPABILITIES:
-
-${workerTypes.map(type => `**${type.toUpperCase()}:**
-${getWorkerTypeInstructions(type)}`).join('\n\n')}
-
-### 🚨 PERFORMANCE OPTIMIZATION RULES:
-
-1. **Token Reduction**: Batch operations reduce context switching by 32.3%
-2. **Speed Improvement**: Parallel coordination is 2.8-4.4x faster
-3. **Memory Efficiency**: Shared memory prevents duplicate work
-4. **Coordination Quality**: Batch patterns improve decision consistency
-
-### 📊 VISUAL COORDINATION TRACKING:
-
-Use this format for progress updates:
-\`\`\`
-🐝 Swarm Coordination Status
-├── 🏗️ Agent: multi-role (${workerTypes.join(', ')})
-├── 👥 Swarm: ${swarmName}
-├── ⚡ Mode: parallel batch execution
-├── 📊 Progress: X/Y tasks (Z% complete)
-└── 🧠 Memory: N coordination points stored
-
-Current Activity:
-├── 🟢 Coordination: Active batch operations
-├── 🟡 Memory: Syncing with swarm
-├── 🔄 Tasks: Executing in parallel
-└── 📈 Performance: Optimized for speed
-\`\`\`
-
-### 🤝 MANDATORY COORDINATION RULES:
-
-- **NEVER** operate sequentially when batch operations are possible
-- **ALWAYS** use BatchTool for multiple operations
-- **SHARE** all discoveries via memory_usage in batch
-- **VOTE** on critical decisions using consensus_vote
-- **UPDATE** progress every major step via task_orchestrate
-- **MONITOR** other agents via swarm_status
-- **LEARN** from patterns via neural_train
-- **COORDINATE** through shared memory, not individual messages
-
-### 💡 CRITICAL SUCCESS FACTORS:
-
-1. **Batch First Mindset**: Always think "what can be combined?"
-2. **Parallel Execution**: Never wait for one operation to complete another
-3. **Memory Coordination**: Use shared memory for all cross-agent communication
-4. **Real-time Updates**: Keep swarm informed of progress and decisions
-5. **Pattern Learning**: Train neural patterns from successful coordination
-
-### 🛠️ TOOL USAGE GUIDELINES:
-
-**FOR CODE AND WEB OPERATIONS - Use Claude Code Native Tools:**
-- **Code Tasks**: Use Read, Write, Edit, MultiEdit, Bash tools for all file operations
-- **Web Research**: Use WebSearch and WebFetch for web-based research
-- **File Management**: Use Glob, Grep, LS for file system operations
-- **Command Execution**: Use Bash for all system commands and package management
-
-**FOR COORDINATION - Use MCP Swarm Tools:**
-- **Agent Management**: Use mcp__ruv-swarm__agent_spawn for creating agents
-- **Memory Sharing**: Use mcp__ruv-swarm__memory_usage for cross-agent communication
-- **Task Coordination**: Use mcp__ruv-swarm__task_orchestrate for work distribution
-- **Consensus Building**: Use mcp__ruv-swarm__consensus_vote for decisions
-- **Monitoring**: Use mcp__ruv-swarm__swarm_monitor for progress tracking
-
-**EXAMPLE - Correct Tool Selection:**
-\`\`\`
-[BatchTool - Code Development with Coordination]:
-  - Read package.json                    # Claude Code native
-  - Write src/server.js                  # Claude Code native  
-  - Bash "npm install express"           # Claude Code native
-  - WebSearch "Node.js best practices"   # Claude Code native
-  - mcp__ruv-swarm__memory_usage {...}   # MCP for coordination
-  - mcp__ruv-swarm__agent_spawn {...}    # MCP for coordination
-  - TodoWrite {...}                      # Claude Code native
-\`\`\`
-
-Remember: You are part of a COLLECTIVE INTELLIGENCE with PARALLEL COORDINATION. Your success depends on BATCH OPERATIONS, PROPER TOOL SELECTION, and SWARM SYNCHRONIZATION!`;
-
-  const command = `claude "${context.replace(/"/g, '\\"')}" --dangerously-skip-permissions`;
-  
-  return {
-    title: `Unified Multi-Role Agent (${workerTypes.join(', ')})`,
-    command,
-    context,
-    workerType: 'multi-role',
-    count: 1
-  };
-}
-
 /**
  * Get specialized instructions for each worker type
  */