claude-flow 2.0.0-alpha.84 → 2.0.0-alpha.85

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

@@ -2605,7 +2605,7 @@ async function resumeSession(args, flags) {
       const restoredPrompt = generateRestoredSessionPrompt(resumedSession);
 
       // Launch Claude Code with restored context
-      await launchClaudeWithContext(restoredPrompt, flags);
+      await launchClaudeWithContext(restoredPrompt, flags, sessionId);
     } else {
       console.log(
         '\n' +
@@ -2683,76 +2683,173 @@ async function stopSession(args, flags) {
  * Generate prompt for restored session
  */
 function generateRestoredSessionPrompt(session) {
-  const activeAgents = session.agents.filter((a) => a.status === 'active' || a.status === 'busy');
-  const pendingTasks = session.tasks.filter(
-    (t) => t.status === 'pending' || t.status === 'in_progress',
-  );
+  // Get all agents, not just active ones
+  const allAgents = session.agents || [];
+  const activeAgents = allAgents.filter((a) => a.status === 'active' || a.status === 'busy');
+  const idleAgents = allAgents.filter((a) => a.status === 'idle');
+  
+  // Get all tasks categorized by status
+  const allTasks = session.tasks || [];
+  const completedTasks = allTasks.filter((t) => t.status === 'completed');
+  const inProgressTasks = allTasks.filter((t) => t.status === 'in_progress');
+  const pendingTasks = allTasks.filter((t) => t.status === 'pending');
+  
+  // Calculate session duration
+  const sessionStart = new Date(session.created_at);
+  const sessionPaused = session.paused_at ? new Date(session.paused_at) : new Date();
+  const duration = Math.round((sessionPaused - sessionStart) / 1000 / 60); // minutes
+  
+  // Get more checkpoint history
+  const checkpointHistory = session.checkpoints || [];
+  
+  // Get more activity logs
+  const activityLogs = session.recentLogs || [];
+  
+  // Format agent details with their current tasks
+  const formatAgentDetails = (agents) => {
+    if (!agents.length) return 'No agents found';
+    return agents.map(agent => {
+      const agentTasks = allTasks.filter(t => t.agent_id === agent.id);
+      const currentTask = agentTasks.find(t => t.status === 'in_progress');
+      return `• ${agent.name} (${agent.type}) - ${agent.status}${currentTask ? `\n  └─ Working on: ${currentTask.description}` : ''}`;
+    }).join('\n');
+  };
+  
+  // Format task details with more information
+  const formatTaskDetails = (tasks, limit = 15) => {
+    if (!tasks.length) return 'No tasks found';
+    const displayTasks = tasks.slice(0, limit);
+    return displayTasks.map(task => {
+      const agent = allAgents.find(a => a.id === task.agent_id);
+      return `• [${task.priority?.toUpperCase() || 'NORMAL'}] ${task.description}${agent ? ` (Assigned to: ${agent.name})` : ''}${task.created_at ? ` - Created: ${new Date(task.created_at).toLocaleTimeString()}` : ''}`;
+    }).join('\n') + (tasks.length > limit ? `\n... and ${tasks.length - limit} more tasks` : '');
+  };
+  
+  // Format checkpoint details
+  const formatCheckpoints = (checkpoints, limit = 5) => {
+    if (!checkpoints.length) return 'No checkpoints found';
+    const displayCheckpoints = checkpoints.slice(0, limit);
+    return displayCheckpoints.map(cp => 
+      `• ${cp.checkpoint_name} - ${new Date(cp.created_at).toLocaleString()}`
+    ).join('\n');
+  };
+  
+  // Format activity logs with more detail
+  const formatActivityLogs = (logs, limit = 20) => {
+    if (!logs.length) return 'No activity logs found';
+    const displayLogs = logs.slice(0, limit);
+    return displayLogs.map(log => {
+      const timestamp = new Date(log.timestamp).toLocaleTimeString();
+      const agent = log.agent_id ? allAgents.find(a => a.id === log.agent_id) : null;
+      return `[${timestamp}] ${log.message}${agent ? ` (by ${agent.name})` : ''}${log.data ? ` - ${JSON.stringify(log.data)}` : ''}`;
+    }).join('\n');
+  };
+  
+  // Extract metadata if available
+  const metadata = session.metadata || {};
+  const metadataStr = Object.keys(metadata).length > 0 ? 
+    Object.entries(metadata).map(([k, v]) => `• ${k}: ${typeof v === 'object' ? JSON.stringify(v) : v}`).join('\n') : 
+    'No metadata available';
 
   return `🔄 RESUMING HIVE MIND SESSION
 ═══════════════════════════════════
 
-You are resuming a paused Hive Mind session with the following context:
+You are resuming a Hive Mind session with comprehensive context:
 
-SESSION DETAILS:
+📋 SESSION DETAILS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 📌 Session ID: ${session.id}
+📌 Swarm ID: ${session.swarm_id}
 📌 Swarm Name: ${session.swarm_name}
 🎯 Objective: ${session.objective}
-📊 Progress: ${session.statistics.completionPercentage}% complete
-⏸️ Paused: ${new Date(session.paused_at).toLocaleString()}
+📊 Overall Progress: ${session.statistics.completionPercentage}% complete
+⏱️ Session Duration: ${duration} minutes
+📅 Created: ${new Date(session.created_at).toLocaleString()}
+⏸️ Paused: ${session.paused_at ? new Date(session.paused_at).toLocaleString() : 'N/A'}
 ▶️ Resumed: ${new Date().toLocaleString()}
+🔄 Status: ${session.status}
+
+📊 TASK STATISTICS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Total Tasks: ${session.statistics.totalTasks}
+• Completed: ${completedTasks.length} (${session.statistics.totalTasks > 0 ? Math.round((completedTasks.length / session.statistics.totalTasks) * 100) : 0}%)
+• In Progress: ${inProgressTasks.length}
+• Pending: ${pendingTasks.length}
+
+👥 SWARM COMPOSITION (${allAgents.length} agents):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Active Agents (${activeAgents.length}):
+${formatAgentDetails(activeAgents)}
+
+Idle Agents (${idleAgents.length}):
+${formatAgentDetails(idleAgents)}
+
+📝 COMPLETED TASKS (${completedTasks.length}):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${formatTaskDetails(completedTasks, 10)}
+
+🔄 IN-PROGRESS TASKS (${inProgressTasks.length}):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${formatTaskDetails(inProgressTasks)}
 
-CURRENT STATUS:
-• Total Agents: ${session.statistics.totalAgents}
-• Active Agents: ${session.statistics.activeAgents}
-• Completed Tasks: ${session.statistics.completedTasks}/${session.statistics.totalTasks}
-• Pending Tasks: ${pendingTasks.length}
+⏳ PENDING TASKS (${pendingTasks.length}):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${formatTaskDetails(pendingTasks)}
 
-ACTIVE AGENTS:
-${activeAgents.map((agent) => `• ${agent.name} (${agent.type}) - ${agent.status}`).join('\n')}
+💾 CHECKPOINT HISTORY (${checkpointHistory.length} total):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${formatCheckpoints(checkpointHistory)}
 
-PENDING TASKS:
-${pendingTasks
-  .slice(0, 10)
-  .map((task) => `• [${task.priority}] ${task.description}`)
-  .join('\n')}
-${pendingTasks.length > 10 ? `... and ${pendingTasks.length - 10} more tasks` : ''}
+📊 SESSION METADATA:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${metadataStr}
 
-CHECKPOINT DATA:
+💾 LAST CHECKPOINT DATA:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 ${session.checkpoint_data ? JSON.stringify(session.checkpoint_data, null, 2) : 'No checkpoint data available'}
 
-RECENT ACTIVITY:
-${session.recentLogs
-  .slice(0, 10)
-  .map((log) => `[${new Date(log.timestamp).toLocaleTimeString()}] ${log.message}`)
-  .join('\n')}
+📜 ACTIVITY LOG (Last ${Math.min(20, activityLogs.length)} entries):
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${formatActivityLogs(activityLogs, 20)}
 
 🎯 RESUMPTION PROTOCOL:
-
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 1. **RESTORE CONTEXT**:
-   - Review the checkpoint data and recent activity
-   - Check collective memory for important decisions
-   - Verify agent status and reassign if needed
+   - Review all checkpoint data and activity history above
+   - Use mcp__claude-flow__memory_usage to retrieve collective memory
+   - Check agent statuses and reassign tasks if needed
+   - Verify all in-progress tasks are still valid
 
 2. **CONTINUE EXECUTION**:
-   - Resume pending tasks based on priority
-   - Maintain coordination with existing agents
-   - Update progress tracking regularly
-
-3. **COORDINATION**:
-   - Use mcp__claude-flow__memory_retrieve to access shared knowledge
-   - Continue using consensus mechanisms for decisions
-   - Maintain swarm communication protocols
-
-Resume the hive mind operation and continue working towards the objective.`;
+   - Resume in-progress tasks with their assigned agents
+   - Process pending tasks based on priority (CRITICAL > HIGH > NORMAL > LOW)
+   - Maintain agent coordination through memory sharing
+   - Update progress tracking after each task completion
+
+3. **COORDINATION REQUIREMENTS**:
+   - Use mcp__claude-flow__memory_usage for all cross-agent communication
+   - Apply consensus mechanisms for important decisions
+   - Maintain swarm topology: ${session.swarm?.topology || 'unknown'}
+   - Keep session checkpoint data updated regularly
+
+4. **MEMORY CONTEXT**:
+   - Session memory namespace: session-${session.id}
+   - Swarm memory namespace: swarm-${session.swarm_id}
+   - Use these namespaces to access historical decisions and context
+
+Resume the hive mind operation with full context awareness and continue working towards the objective.`;
 }
 
 /**
  * Launch Claude Code with context
  */
-async function launchClaudeWithContext(prompt, flags) {
+async function launchClaudeWithContext(prompt, flags, sessionId) {
   try {
     // ALWAYS save the prompt file first (fix for issue #330)
-    const promptFile = `hive-mind-resume-${Date.now()}.txt`;
+    // Ensure sessions directory exists
+    const sessionsDir = path.join('.hive-mind', 'sessions');
+    await mkdirAsync(sessionsDir, { recursive: true });
+    const promptFile = path.join(sessionsDir, `hive-mind-resume-${sessionId}-${Date.now()}.txt`);
     await writeFile(promptFile, prompt);
     console.log(chalk.green(`\n✓ Session context saved to: ${promptFile}`));
 
@@ -2770,55 +2867,91 @@ async function launchClaudeWithContext(prompt, flags) {
     }
 
     if (claudeAvailable && !flags.dryRun) {
-      const claudeArgs = [prompt, '--print'];
+      // Debug logging to track spawn calls
+      console.log(chalk.blue('\n🔍 Debug: About to spawn Claude Code process...'));
+      console.log(chalk.gray(`  Session ID: ${sessionId}`));
+      console.log(chalk.gray(`  Process ID: ${process.pid}`));
+      
+      // Remove --print to allow interactive session (same as initial spawn)
+      const claudeArgs = [prompt];
 
-      if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+      // Add --dangerously-skip-permissions by default for hive-mind operations
+      // unless explicitly disabled with --no-auto-permissions
+      if (!flags['no-auto-permissions']) {
         claudeArgs.push('--dangerously-skip-permissions');
+        console.log(
+          chalk.yellow(
+            '🔓 Using --dangerously-skip-permissions by default for seamless hive-mind execution',
+          ),
+        );
       }
 
-      // Use 'pipe' instead of 'inherit' to prevent terminal conflicts
+      console.log(chalk.blue('🔍 Debug: Spawning with args:'), claudeArgs.slice(0, 1).map(a => a.substring(0, 50) + '...'));
+      
+      // Use 'inherit' for interactive session (same as initial spawn)
       const claudeProcess = childSpawn('claude', claudeArgs, {
-        stdio: 'pipe',
+        stdio: 'inherit',
         shell: false,
       });
+      
+      console.log(chalk.blue('🔍 Debug: Claude process spawned with PID:'), claudeProcess.pid);
+
+      // Track child process PID in session (same as initial spawn)
+      const sessionManager = new HiveMindSessionManager();
+      if (claudeProcess.pid) {
+        const sessions = await sessionManager.getActiveSessions();
+        const currentSession = sessions.find(s => s.id === sessionId);
+        if (currentSession) {
+          await sessionManager.addChildPid(currentSession.id, claudeProcess.pid);
+        }
+      }
+
+      // Set up SIGINT handler for automatic session pausing (same as initial spawn)
+      let isExiting = false;
+      const sigintHandler = async () => {
+        if (isExiting) return;
+        isExiting = true;
 
-      // Set up SIGINT handler for clean termination (no session pausing here since we're resuming)
-      const sigintHandler = () => {
-        console.log('\n\n' + chalk.yellow('⏹️  Terminating Claude Code...'));
-        if (claudeProcess && !claudeProcess.killed) {
-          claudeProcess.kill('SIGTERM');
+        console.log('\n\n' + chalk.yellow('⏸️  Pausing session and terminating Claude Code...'));
+        
+        try {
+          // Terminate Claude Code process if still running
+          if (claudeProcess && !claudeProcess.killed) {
+            claudeProcess.kill('SIGTERM');
+          }
+          
+          // Clean up and close session manager
+          sessionManager.close();
+          
+          console.log(chalk.green('✓') + ' Session paused successfully');
+          console.log(chalk.cyan('\nTo resume this session, run:'));
+          console.log(chalk.bold(`  claude-flow hive-mind resume ${sessionId}`));
+          console.log();
+          
+          process.exit(0);
+        } catch (error) {
+          console.error(chalk.red('Error during shutdown:'), error.message);
+          process.exit(1);
         }
-        process.exit(0);
       };
 
       process.on('SIGINT', sigintHandler);
       process.on('SIGTERM', sigintHandler);
 
-      // Handle stdout
-      if (claudeProcess.stdout) {
-        claudeProcess.stdout.on('data', (data) => {
-          console.log(data.toString());
-        });
-      }
-
-      // Handle stderr
-      if (claudeProcess.stderr) {
-        claudeProcess.stderr.on('data', (data) => {
-          console.error(chalk.red(data.toString()));
-        });
-      }
-
-      // Handle process exit
-      claudeProcess.on('exit', (code) => {
-        if (code === 0) {
-          console.log(chalk.green('\n✓ Claude Code completed successfully'));
-        } else if (code !== null) {
-          console.log(chalk.red(`\n✗ Claude Code exited with code ${code}`));
+      // Handle process exit (same as initial spawn)
+      claudeProcess.on('exit', async (code, signal) => {
+        if (!isExiting) {
+          console.log('\n' + chalk.yellow('Claude Code has exited'));
+          
+          // Clean up signal handlers
+          process.removeListener('SIGINT', sigintHandler);
+          process.removeListener('SIGTERM', sigintHandler);
+          
+          // Close session manager
+          sessionManager.close();
+          
+          process.exit(code || 0);
         }
-        
-        // Clean up signal handlers
-        process.removeListener('SIGINT', sigintHandler);
-        process.removeListener('SIGTERM', sigintHandler);
       });
 
       console.log(chalk.green('\n✓ Claude Code launched with restored session context'));

package/src/cli/simple-commands/init/index.js

@@ -54,6 +54,7 @@ import {
   createHelperScript,
   COMMAND_STRUCTURE,
 } from './templates/enhanced-templates.js';
+import { createOptimizedSparcClaudeMd } from './templates/claude-md.js';
 import { getIsolatedNpxEnv } from '../../../utils/npx-isolated-cache.js';
 import { updateGitignore, needsGitignoreUpdate } from './gitignore-updater.js';
 import {
@@ -1047,10 +1048,10 @@ async function enhancedClaudeFlowInit(flags, subArgs = []) {
 
     // Create CLAUDE.md
     if (!dryRun) {
-      await fs.writeFile(`${workingDir}/CLAUDE.md`, createEnhancedClaudeMd(), 'utf8');
-      printSuccess('✓ Created CLAUDE.md (Claude Flow v2.0.0)');
+      await fs.writeFile(`${workingDir}/CLAUDE.md`, createOptimizedSparcClaudeMd(), 'utf8');
+      printSuccess('✓ Created CLAUDE.md (Claude Flow v2.0.0 - Optimized)');
     } else {
-      console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0)');
+      console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0 - Optimized)');
     }
 
     // Create .claude directory structure

package/src/cli/simple-commands/init/templates/CLAUDE.md.optimized

@@ -0,0 +1,265 @@
+# Claude Code Configuration - SPARC Development Environment
+
+## 🚨 CRITICAL: CONCURRENT EXECUTION & FILE MANAGEMENT
+
+**ABSOLUTE RULES**:
+1. ALL operations MUST be concurrent/parallel in a single message
+2. **NEVER save working files, text/mds and tests to the root folder**
+3. ALWAYS organize files in appropriate subdirectories
+
+### ⚡ GOLDEN RULE: "1 MESSAGE = ALL RELATED OPERATIONS"
+
+**MANDATORY PATTERNS:**
+- **TodoWrite**: ALWAYS batch ALL todos in ONE call (5-10+ todos minimum)
+- **Task tool**: ALWAYS spawn ALL agents in ONE message with full instructions
+- **File operations**: ALWAYS batch ALL reads/writes/edits in ONE message
+- **Bash commands**: ALWAYS batch ALL terminal operations in ONE message
+- **Memory operations**: ALWAYS batch ALL memory store/retrieve in ONE message
+
+### 📁 File Organization Rules
+
+**NEVER save to root folder. Use these directories:**
+- `/src` - Source code files
+- `/tests` - Test files
+- `/docs` - Documentation and markdown files
+- `/config` - Configuration files
+- `/scripts` - Utility scripts
+- `/examples` - Example code
+
+## Project Overview
+
+This project uses SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) methodology with Claude-Flow orchestration for systematic Test-Driven Development.
+
+## SPARC Commands
+
+### Core Commands
+- `npx claude-flow sparc modes` - List available modes
+- `npx claude-flow sparc run <mode> "<task>"` - Execute specific mode
+- `npx claude-flow sparc tdd "<feature>"` - Run complete TDD workflow
+- `npx claude-flow sparc info <mode>` - Get mode details
+
+### Batchtools Commands
+- `npx claude-flow sparc batch <modes> "<task>"` - Parallel execution
+- `npx claude-flow sparc pipeline "<task>"` - Full pipeline processing
+- `npx claude-flow sparc concurrent <mode> "<tasks-file>"` - Multi-task processing
+
+### Build Commands
+- `npm run build` - Build project
+- `npm run test` - Run tests
+- `npm run lint` - Linting
+- `npm run typecheck` - Type checking
+
+## SPARC Workflow Phases
+
+1. **Specification** - Requirements analysis (`sparc run spec-pseudocode`)
+2. **Pseudocode** - Algorithm design (`sparc run spec-pseudocode`)
+3. **Architecture** - System design (`sparc run architect`)
+4. **Refinement** - TDD implementation (`sparc tdd`)
+5. **Completion** - Integration (`sparc run integration`)
+
+## Code Style & Best Practices
+
+- **Modular Design**: Files under 500 lines
+- **Environment Safety**: Never hardcode secrets
+- **Test-First**: Write tests before implementation
+- **Clean Architecture**: Separate concerns
+- **Documentation**: Keep updated
+
+## 🚀 Available Agents (54 Total)
+
+### Core Development
+`coder`, `reviewer`, `tester`, `planner`, `researcher`
+
+### Swarm Coordination
+`hierarchical-coordinator`, `mesh-coordinator`, `adaptive-coordinator`, `collective-intelligence-coordinator`, `swarm-memory-manager`
+
+### Consensus & Distributed
+`byzantine-coordinator`, `raft-manager`, `gossip-coordinator`, `consensus-builder`, `crdt-synchronizer`, `quorum-manager`, `security-manager`
+
+### Performance & Optimization
+`perf-analyzer`, `performance-benchmarker`, `task-orchestrator`, `memory-coordinator`, `smart-agent`
+
+### GitHub & Repository
+`github-modes`, `pr-manager`, `code-review-swarm`, `issue-tracker`, `release-manager`, `workflow-automation`, `project-board-sync`, `repo-architect`, `multi-repo-swarm`
+
+### SPARC Methodology
+`sparc-coord`, `sparc-coder`, `specification`, `pseudocode`, `architecture`, `refinement`
+
+### Specialized Development
+`backend-dev`, `mobile-dev`, `ml-developer`, `cicd-engineer`, `api-docs`, `system-architect`, `code-analyzer`, `base-template-generator`
+
+### Testing & Validation
+`tdd-london-swarm`, `production-validator`
+
+### Migration & Planning
+`migration-planner`, `swarm-init`
+
+## 🎯 Claude Code vs MCP Tools
+
+### Claude Code Handles ALL:
+- File operations (Read, Write, Edit, MultiEdit, Glob, Grep)
+- Code generation and programming
+- Bash commands and system operations
+- Implementation work
+- Project navigation and analysis
+- TodoWrite and task management
+- Git operations
+- Package management
+- Testing and debugging
+
+### MCP Tools ONLY:
+- Coordination and planning
+- Memory management
+- Neural features
+- Performance tracking
+- Swarm orchestration
+- GitHub integration
+
+**KEY**: MCP coordinates, Claude Code executes.
+
+## 🚀 Quick Setup
+
+```bash
+# Add Claude Flow MCP server
+claude mcp add claude-flow npx claude-flow@alpha mcp start
+```
+
+## MCP Tool Categories
+
+### Coordination
+`swarm_init`, `agent_spawn`, `task_orchestrate`
+
+### Monitoring
+`swarm_status`, `agent_list`, `agent_metrics`, `task_status`, `task_results`
+
+### Memory & Neural
+`memory_usage`, `neural_status`, `neural_train`, `neural_patterns`
+
+### GitHub Integration
+`github_swarm`, `repo_analyze`, `pr_enhance`, `issue_triage`, `code_review`
+
+### System
+`benchmark_run`, `features_detect`, `swarm_monitor`
+
+## 📋 Agent Coordination Protocol
+
+### Every Agent MUST:
+
+**1️⃣ BEFORE Work:**
+```bash
+npx claude-flow@alpha hooks pre-task --description "[task]"
+npx claude-flow@alpha hooks session-restore --session-id "swarm-[id]"
+```
+
+**2️⃣ DURING Work:**
+```bash
+npx claude-flow@alpha hooks post-edit --file "[file]" --memory-key "swarm/[agent]/[step]"
+npx claude-flow@alpha hooks notify --message "[what was done]"
+```
+
+**3️⃣ AFTER Work:**
+```bash
+npx claude-flow@alpha hooks post-task --task-id "[task]"
+npx claude-flow@alpha hooks session-end --export-metrics true
+```
+
+## 🎯 Concurrent Execution Examples
+
+### ✅ CORRECT (Single Message):
+```javascript
+[BatchTool]:
+  // Initialize swarm
+  mcp__claude-flow__swarm_init { topology: "mesh", maxAgents: 6 }
+  mcp__claude-flow__agent_spawn { type: "researcher" }
+  mcp__claude-flow__agent_spawn { type: "coder" }
+  mcp__claude-flow__agent_spawn { type: "tester" }
+  
+  // Spawn agents with Task tool
+  Task("Research agent: Analyze requirements...")
+  Task("Coder agent: Implement features...")
+  Task("Tester agent: Create test suite...")
+  
+  // Batch todos
+  TodoWrite { todos: [
+    {id: "1", content: "Research", status: "in_progress", priority: "high"},
+    {id: "2", content: "Design", status: "pending", priority: "high"},
+    {id: "3", content: "Implement", status: "pending", priority: "high"},
+    {id: "4", content: "Test", status: "pending", priority: "medium"},
+    {id: "5", content: "Document", status: "pending", priority: "low"}
+  ]}
+  
+  // File operations
+  Bash "mkdir -p app/{src,tests,docs}"
+  Write "app/src/index.js"
+  Write "app/tests/index.test.js"
+  Write "app/docs/README.md"
+```
+
+### ❌ WRONG (Multiple Messages):
+```javascript
+Message 1: mcp__claude-flow__swarm_init
+Message 2: Task("agent 1")
+Message 3: TodoWrite { todos: [single todo] }
+Message 4: Write "file.js"
+// This breaks parallel coordination!
+```
+
+## Performance Benefits
+
+- **84.8% SWE-Bench solve rate**
+- **32.3% token reduction**
+- **2.8-4.4x speed improvement**
+- **27+ neural models**
+
+## Hooks Integration
+
+### Pre-Operation
+- Auto-assign agents by file type
+- Validate commands for safety
+- Prepare resources automatically
+- Optimize topology by complexity
+- Cache searches
+
+### Post-Operation
+- Auto-format code
+- Train neural patterns
+- Update memory
+- Analyze performance
+- Track token usage
+
+### Session Management
+- Generate summaries
+- Persist state
+- Track metrics
+- Restore context
+- Export workflows
+
+## Advanced Features (v2.0.0)
+
+- 🚀 Automatic Topology Selection
+- ⚡ Parallel Execution (2.8-4.4x speed)
+- 🧠 Neural Training
+- 📊 Bottleneck Analysis
+- 🤖 Smart Auto-Spawning
+- 🛡️ Self-Healing Workflows
+- 💾 Cross-Session Memory
+- 🔗 GitHub Integration
+
+## Integration Tips
+
+1. Start with basic swarm init
+2. Scale agents gradually
+3. Use memory for context
+4. Monitor progress regularly
+5. Train patterns from success
+6. Enable hooks automation
+7. Use GitHub tools first
+
+## Support
+
+- Documentation: https://github.com/ruvnet/claude-flow
+- Issues: https://github.com/ruvnet/claude-flow/issues
+
+---
+
+Remember: **Claude Flow coordinates, Claude Code creates!**