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

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

@@ -308,8 +308,10 @@ const hiveMindWizard = safeInteractive(
       name: flags.name || `swarm-${Date.now()}`,
       queenType: flags.queenType || flags['queen-type'] || 'strategic',
       maxWorkers: parseInt(flags.maxWorkers || flags['max-workers'] || '8'),
-      consensusAlgorithm: flags.consensus || 'majority',
+      consensusAlgorithm: flags.consensus || flags.consensusAlgorithm || 'majority',
       autoScale: flags.autoScale || flags['auto-scale'] || false,
+      namespace: flags.namespace || 'default',
+      verbose: flags.verbose || false,
       encryption: flags.encryption || false,
     };
 
@@ -405,11 +407,16 @@ async function spawnSwarmWizard() {
   await spawnSwarm([answers.objective], {
     name: answers.name,
     queenType: answers.queenType,
+    'queen-type': answers.queenType,
     maxWorkers: answers.maxWorkers,
+    'max-workers': answers.maxWorkers,
     workerTypes: answers.workerTypes.join(','),
     consensus: answers.consensusAlgorithm,
     autoScale: answers.autoScale,
+    'auto-scale': answers.autoScale,
     monitor: answers.monitor,
+    namespace: answers.namespace || 'default',
+    verbose: answers.verbose || false,
   });
 }
 
@@ -425,6 +432,35 @@ async function spawnSwarm(args, flags) {
     return;
   }
 
+  // Validate parameters
+  if (flags.verbose) {
+    console.log(chalk.gray('🔍 Debug: Parsed flags:'));
+    console.log(chalk.gray(JSON.stringify(flags, null, 2)));
+  }
+
+  // Validate queen type
+  const validQueenTypes = ['strategic', 'tactical', 'adaptive'];
+  const queenType = flags.queenType || flags['queen-type'] || 'strategic';
+  if (!validQueenTypes.includes(queenType)) {
+    console.error(chalk.red(`Error: Invalid queen type '${queenType}'. Must be one of: ${validQueenTypes.join(', ')}`));
+    return;
+  }
+
+  // Validate max workers
+  const maxWorkers = parseInt(flags.maxWorkers || flags['max-workers'] || '8');
+  if (isNaN(maxWorkers) || maxWorkers < 1 || maxWorkers > 20) {
+    console.error(chalk.red('Error: max-workers must be a number between 1 and 20'));
+    return;
+  }
+
+  // Validate consensus algorithm
+  const validConsensusTypes = ['majority', 'weighted', 'byzantine'];
+  const consensusAlgorithm = flags.consensus || flags.consensusAlgorithm || 'majority';
+  if (!validConsensusTypes.includes(consensusAlgorithm)) {
+    console.error(chalk.red(`Error: Invalid consensus algorithm '${consensusAlgorithm}'. Must be one of: ${validConsensusTypes.join(', ')}`));
+    return;
+  }
+
   const spinner = ora('Spawning Hive Mind swarm...').start();
 
   try {
@@ -435,10 +471,11 @@ async function spawnSwarm(args, flags) {
       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,
+        queenType: flags.queenType || flags['queen-type'] || 'strategic',
+        maxWorkers: parseInt(flags.maxWorkers || flags['max-workers'] || '8'),
+        consensusAlgorithm: flags.consensus || flags.consensusAlgorithm || 'majority',
+        autoScale: flags.autoScale !== undefined ? flags.autoScale : (flags['auto-scale'] !== undefined ? flags['auto-scale'] : true),
+        namespace: flags.namespace || 'default',
         encryption: flags.encryption || false,
       });
     } catch (error) {
@@ -574,7 +611,7 @@ async function spawnSwarm(args, flags) {
     // Create session for this swarm
     spinner.text = 'Creating session tracking...';
     const sessionManager = new HiveMindSessionManager();
-    const sessionId = sessionManager.createSession(swarmId, hiveMind.config.name, objective, {
+    const sessionId = await sessionManager.createSession(swarmId, hiveMind.config.name, objective, {
       queenType: hiveMind.config.queenType,
       maxWorkers: hiveMind.config.maxWorkers,
       consensusAlgorithm: hiveMind.config.consensusAlgorithm,
@@ -584,14 +621,16 @@ async function spawnSwarm(args, flags) {
     });
 
     spinner.text = 'Session tracking established...';
-    sessionManager.close();
 
-    // Initialize auto-save middleware
-    const autoSave = createAutoSaveMiddleware(sessionId, {
+    // Initialize auto-save middleware (use the same session manager)
+    const autoSave = createAutoSaveMiddleware(sessionId, sessionManager, {
       saveInterval: 30000, // Save every 30 seconds
       autoStart: true,
     });
 
+    // Close session manager after auto-save is set up
+    // sessionManager.close(); // Don't close yet as auto-save needs it
+
     // Track initial swarm creation
     autoSave.trackChange('swarm_created', {
       swarmId,
@@ -719,6 +758,59 @@ async function spawnSwarm(args, flags) {
     console.log(chalk.blue('💡 To pause:') + ' Press Ctrl+C to safely pause and resume later');
     console.log(chalk.blue('💡 To resume:') + ' claude-flow hive-mind resume ' + sessionId);
 
+    // Set up SIGINT handler for automatic session pausing
+    let isExiting = false;
+    const sigintHandler = async () => {
+      if (isExiting) return;
+      isExiting = true;
+
+      console.log('\n\n' + chalk.yellow('⏸️  Pausing session...'));
+      
+      try {
+        // Save current checkpoint using the existing session manager
+        // const sessionManager = new HiveMindSessionManager(); // Use existing one
+        
+        // Create checkpoint data
+        const checkpointData = {
+          timestamp: new Date().toISOString(),
+          swarmId,
+          objective,
+          workerCount: workers.length,
+          workerTypes,
+          status: 'paused_by_user',
+          reason: 'User pressed Ctrl+C',
+        };
+        
+        // Save checkpoint
+        await sessionManager.saveCheckpoint(sessionId, 'auto-pause', checkpointData);
+        
+        // Pause the session
+        await sessionManager.pauseSession(sessionId);
+        
+        // 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();
+        
+        // Clean up auto-save if active
+        if (global.autoSaveInterval) {
+          clearInterval(global.autoSaveInterval);
+        }
+        
+        process.exit(0);
+      } catch (error) {
+        console.error(chalk.red('Error pausing session:'), error.message);
+        process.exit(1);
+      }
+    };
+
+    // Register SIGINT handler
+    process.on('SIGINT', sigintHandler);
+    process.on('SIGTERM', sigintHandler);
+
     // Offer to spawn Claude Code instances with coordination instructions
     if (flags.claude || flags.spawn) {
       await spawnClaudeCodeInstances(swarmId, hiveMind.config.name, objective, workers, flags);
@@ -1771,6 +1863,20 @@ async function exportMemoryBackup() {
   }
 }
 
+/**
+ * Get active session ID for a swarm
+ */
+async function getActiveSessionId(swarmId) {
+  const sessionManager = new HiveMindSessionManager();
+  try {
+    const sessions = sessionManager.getActiveSessions();
+    const activeSession = sessions.find(s => s.swarm_id === swarmId && s.status === 'active');
+    return activeSession ? activeSession.id : null;
+  } finally {
+    sessionManager.close();
+  }
+}
+
 /**
  * Spawn Claude Code with Hive Mind coordination instructions
  */
@@ -1850,6 +1956,59 @@ async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers,
           shell: false,
         });
 
+        // Track child process PID in session
+        const sessionManager = new HiveMindSessionManager();
+        const sessionId = await getActiveSessionId(swarmId);
+        if (sessionId && claudeProcess.pid) {
+          sessionManager.addChildPid(sessionId, claudeProcess.pid);
+        }
+
+        // Set up SIGINT handler for automatic session pausing
+        let isExiting = false;
+        const sigintHandler = async () => {
+          if (isExiting) return;
+          isExiting = true;
+
+          console.log('\n\n' + chalk.yellow('⏸️  Pausing session and terminating Claude Code...'));
+          
+          try {
+            // Terminate Claude Code process
+            if (claudeProcess && !claudeProcess.killed) {
+              claudeProcess.kill('SIGTERM');
+            }
+
+            // Save checkpoint and pause session
+            if (sessionId) {
+              const checkpointData = {
+                timestamp: new Date().toISOString(),
+                swarmId,
+                objective,
+                status: 'paused_by_user',
+                reason: 'User pressed Ctrl+C during Claude Code execution',
+                claudePid: claudeProcess.pid,
+              };
+              
+              await sessionManager.saveCheckpoint(sessionId, 'auto-pause-claude', checkpointData);
+              await sessionManager.pauseSession(sessionId);
+              
+              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}`));
+            }
+            
+            sessionManager.close();
+            process.exit(0);
+          } catch (error) {
+            console.error(chalk.red('Error pausing session:'), error.message);
+            sessionManager.close();
+            process.exit(1);
+          }
+        };
+
+        // Register SIGINT handler
+        process.on('SIGINT', sigintHandler);
+        process.on('SIGTERM', sigintHandler);
+
         // Handle stdout
         if (claudeProcess.stdout) {
           claudeProcess.stdout.on('data', (data) => {
@@ -1866,9 +2025,15 @@ async function spawnClaudeCodeInstances(swarmId, swarmName, objective, workers,
 
         // Handle process exit
         claudeProcess.on('exit', (code) => {
+          // Remove child PID from session
+          if (sessionId && claudeProcess.pid) {
+            sessionManager.removeChildPid(sessionId, claudeProcess.pid);
+            sessionManager.close();
+          }
+
           if (code === 0) {
             console.log(chalk.green('\n✓ Claude Code completed successfully'));
-          } else {
+          } else if (code !== null) {
             console.log(chalk.red(`\n✗ Claude Code exited with code ${code}`));
           }
         });
@@ -2574,6 +2739,18 @@ async function launchClaudeWithContext(prompt, flags) {
         shell: false,
       });
 
+      // 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');
+        }
+        process.exit(0);
+      };
+
+      process.on('SIGINT', sigintHandler);
+      process.on('SIGTERM', sigintHandler);
+
       // Handle stdout
       if (claudeProcess.stdout) {
         claudeProcess.stdout.on('data', (data) => {
@@ -2592,9 +2769,13 @@ async function launchClaudeWithContext(prompt, flags) {
       claudeProcess.on('exit', (code) => {
         if (code === 0) {
           console.log(chalk.green('\n✓ Claude Code completed successfully'));
-        } else {
+        } else if (code !== null) {
           console.log(chalk.red(`\n✗ Claude Code exited with code ${code}`));
         }
+        
+        // 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/claude-commands/optimized-slash-commands.js

@@ -5,39 +5,65 @@ import {
   createOptimizedMainSparcCommand,
 } from './optimized-sparc-commands.js';
 import { createOptimizedClaudeFlowCommands } from './optimized-claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
 
 // Create batchtools-optimized Claude Code slash commands for SPARC modes
 export async function createOptimizedClaudeSlashCommands(workingDir, selectedModes = null) {
   try {
     console.log('\n🚀 Creating batchtools-optimized Claude Code slash commands...');
 
-    // Parse .roomodes to get all SPARC modes
-    const roomodesContent = await Deno.readTextFile(`${workingDir}/.roomodes`);
-    const roomodes = JSON.parse(roomodesContent);
-
-    // Filter modes if selective initialization is requested
-    const modesToCreate = selectedModes
-      ? roomodes.customModes.filter((mode) => selectedModes.includes(mode.slug))
-      : roomodes.customModes;
-
-    console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
-
-    // Create slash commands for each SPARC mode with batchtools optimization
-    const commandPromises = modesToCreate.map(async (mode) => {
-      const commandPath = `${workingDir}/.claude/commands/sparc/${mode.slug}.md`;
-      const commandContent = createOptimizedSparcSlashCommand(mode);
-
-      await Deno.writeTextFile(commandPath, commandContent);
-      console.log(`  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`);
-    });
-
-    // Execute all command creations in parallel
-    await Promise.all(commandPromises);
-
-    // Create main SPARC command with batchtools optimization
-    const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
-    await Deno.writeTextFile(`${workingDir}/.claude/commands/sparc.md`, mainSparcCommand);
-    console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
+    // Use template copier with optimized flag
+    const optimizedOptions = {
+      sparc: true,
+      optimized: true,
+      force: true,
+      dryRun: false,
+      selectedModes: selectedModes,
+    };
+
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
+    try {
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
+
+      // Filter modes if selective initialization is requested
+      const modesToCreate = selectedModes
+        ? roomodes.customModes.filter((mode) => selectedModes.includes(mode.slug))
+        : roomodes.customModes;
+
+      console.log(`  📝 Creating optimized commands for ${modesToCreate.length} modes...`);
+
+      // Create slash commands for each SPARC mode with batchtools optimization
+      const commandPromises = modesToCreate.map(async (mode) => {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createOptimizedSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent);
+        console.log(`  ✓ Created optimized slash command: /sparc-${mode.slug} (Batchtools enhanced)`);
+      });
+
+      // Execute all command creations in parallel
+      await Promise.all(commandPromises);
+
+      // Create main SPARC command with batchtools optimization
+      const mainSparcCommand = createOptimizedMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
+      console.log('  ✅ Created optimized main slash command: /sparc (Batchtools enhanced)');
+
+      console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
+    } catch (err) {
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for optimized SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, optimizedOptions);
+      
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
+    }
 
     // Create claude-flow specific commands with batchtools optimization
     await createOptimizedClaudeFlowCommands(workingDir);
@@ -45,7 +71,6 @@ export async function createOptimizedClaudeSlashCommands(workingDir, selectedMod
     // Create batchtools-specific commands
     await createBatchtoolsCommands(workingDir);
 
-    console.log(`  🎯 Total optimized commands created: ${modesToCreate.length + 5}`);
     console.log('  💡 All commands include parallel processing and performance optimizations');
   } catch (err) {
     console.log(`  ⚠️  Could not create optimized Claude Code slash commands: ${err.message}`);

package/src/cli/simple-commands/init/claude-commands/slash-commands.js

@@ -2,29 +2,51 @@
 
 import { createSparcSlashCommand, createMainSparcCommand } from './sparc-commands.js';
 import { createClaudeFlowCommands } from './claude-flow-commands.js';
+import { copyTemplates } from '../template-copier.js';
+import { promises as fs } from 'fs';
+import { join } from 'path';
 
 // Create Claude Code slash commands for SPARC modes
 export async function createClaudeSlashCommands(workingDir) {
   try {
     console.log('\n📝 Creating Claude Code slash commands...');
 
-    // Parse .roomodes to get all SPARC modes
-    const roomodesContent = await Deno.readTextFile(`${workingDir}/.roomodes`);
-    const roomodes = JSON.parse(roomodesContent);
+    // Use template copier for SPARC slash commands
+    const slashCommandOptions = {
+      sparc: true,
+      force: true,
+      dryRun: false,
+    };
 
-    // Create slash commands for each SPARC mode
-    for (const mode of roomodes.customModes) {
-      const commandPath = `${workingDir}/.claude/commands/sparc/${mode.slug}.md`;
-      const commandContent = createSparcSlashCommand(mode);
+    // Check if .roomodes exists for dynamic generation
+    const roomodesPath = `${workingDir}/.roomodes`;
+    try {
+      const roomodesContent = await fs.readFile(roomodesPath, 'utf8');
+      const roomodes = JSON.parse(roomodesContent);
 
-      await Deno.writeTextFile(commandPath, commandContent);
-      console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
-    }
+      // Create slash commands for each SPARC mode
+      for (const mode of roomodes.customModes) {
+        const commandPath = join(workingDir, '.claude', 'commands', 'sparc', `${mode.slug}.md`);
+        const commandContent = createSparcSlashCommand(mode);
+
+        await fs.mkdir(join(workingDir, '.claude', 'commands', 'sparc'), { recursive: true });
+        await fs.writeFile(commandPath, commandContent);
+        console.log(`  ✓ Created slash command: /sparc-${mode.slug}`);
+      }
 
-    // Create main SPARC command
-    const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
-    await Deno.writeTextFile(`${workingDir}/.claude/commands/sparc.md`, mainSparcCommand);
-    console.log('  ✓ Created main slash command: /sparc');
+      // Create main SPARC command
+      const mainSparcCommand = createMainSparcCommand(roomodes.customModes);
+      await fs.writeFile(join(workingDir, '.claude', 'commands', 'sparc.md'), mainSparcCommand);
+      console.log('  ✓ Created main slash command: /sparc');
+    } catch (err) {
+      // Fallback to template copier if .roomodes doesn't exist
+      console.log('  🔄 Using template copier for SPARC commands...');
+      const copyResults = await copyTemplates(workingDir, slashCommandOptions);
+      
+      if (!copyResults.success) {
+        console.log(`  ⚠️  Template copier failed: ${copyResults.errors.join(', ')}`);
+      }
+    }
 
     // Create claude-flow specific commands
     await createClaudeFlowCommands(workingDir);

package/src/cli/simple-commands/init/claude-commands/sparc-commands.js

@@ -39,34 +39,66 @@ ${
 
 ## Usage
 
-To use this SPARC mode, you can:
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+\`\`\`javascript
+mcp__claude-flow__sparc_mode {
+  mode: "${mode.slug}",
+  task_description: "${getExampleTask(mode.slug)}",
+  options: {
+    namespace: "${mode.slug}",
+    non_interactive: false
+  }
+}
+\`\`\`
 
-1. **Run directly**: \`./claude-flow sparc run ${mode.slug} "your task"\`
-2. **TDD shorthand** (if applicable): \`./claude-flow sparc ${mode.slug} "your task"\`
-3. **Use in workflow**: Include \`${mode.slug}\` in your SPARC workflow
-4. **Delegate tasks**: Use \`new_task\` to assign work to this mode
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+\`\`\`bash
+# Use when running from terminal or MCP tools unavailable
+npx claude-flow sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
 
-## Example Commands
+# For alpha features
+npx claude-flow@alpha sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
 
-\`\`\`bash
-# Run this specific mode
-./claude-flow sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
+# With namespace
+npx claude-flow sparc run ${mode.slug} "your task" --namespace ${mode.slug}
 
-# Use with memory namespace
-./claude-flow sparc run ${mode.slug} "your task" --namespace ${mode.slug}
+# Non-interactive mode
+npx claude-flow sparc run ${mode.slug} "your task" --non-interactive
+\`\`\`
 
-# Non-interactive mode for automation
-./claude-flow sparc run ${mode.slug} "your task" --non-interactive
+### Option 3: Local Installation
+\`\`\`bash
+# If claude-flow is installed locally
+./claude-flow sparc run ${mode.slug} "${getExampleTask(mode.slug)}"
 \`\`\`
 
 ## Memory Integration
 
+### Using MCP Tools (Preferred)
+\`\`\`javascript
+// Store mode-specific context
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "${mode.slug}_context",
+  value: "important decisions",
+  namespace: "${mode.slug}"
+}
+
+// Query previous work
+mcp__claude-flow__memory_search {
+  pattern: "${mode.slug}",
+  namespace: "${mode.slug}",
+  limit: 5
+}
+\`\`\`
+
+### Using NPX CLI (Fallback)
 \`\`\`bash
 # Store mode-specific context
-./claude-flow memory store "${mode.slug}_context" "important decisions" --namespace ${mode.slug}
+npx claude-flow memory store "${mode.slug}_context" "important decisions" --namespace ${mode.slug}
 
 # Query previous work
-./claude-flow memory query "${mode.slug}" --limit 5
+npx claude-flow memory query "${mode.slug}" --limit 5
 \`\`\`
 `;
 }
@@ -137,26 +169,52 @@ ${modeList}
 
 ## Quick Start
 
-### Run SPARC orchestrator (default):
-\`\`\`bash
-./claude-flow sparc "build complete authentication system"
-\`\`\`
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+\`\`\`javascript
+// Run SPARC orchestrator (default)
+mcp__claude-flow__sparc_mode {
+  mode: "sparc",
+  task_description: "build complete authentication system"
+}
 
-### Run a specific mode:
-\`\`\`bash
-./claude-flow sparc run <mode> "your task"
-./claude-flow sparc run architect "design API structure"
-./claude-flow sparc run tdd "implement user service"
+// Run a specific mode
+mcp__claude-flow__sparc_mode {
+  mode: "architect",
+  task_description: "design API structure"
+}
+
+// TDD workflow
+mcp__claude-flow__sparc_mode {
+  mode: "tdd",
+  task_description: "implement user authentication",
+  options: {workflow: "full"}
+}
 \`\`\`
 
-### Execute full TDD workflow:
+### Option 2: Using NPX CLI (Fallback when MCP not available)
 \`\`\`bash
-./claude-flow sparc tdd "implement user authentication"
+# Run SPARC orchestrator (default)
+npx claude-flow sparc "build complete authentication system"
+
+# Run a specific mode
+npx claude-flow sparc run architect "design API structure"
+npx claude-flow sparc run tdd "implement user service"
+
+# Execute full TDD workflow
+npx claude-flow sparc tdd "implement user authentication"
+
+# List all modes with details
+npx claude-flow sparc modes --verbose
+
+# For alpha features
+npx claude-flow@alpha sparc run <mode> "your task"
 \`\`\`
 
-### List all modes with details:
+### Option 3: Local Installation
 \`\`\`bash
-./claude-flow sparc modes --verbose
+# If claude-flow is installed locally
+./claude-flow sparc "build complete authentication system"
+./claude-flow sparc run architect "design API structure"
 \`\`\`
 
 ## SPARC Methodology Phases
@@ -169,10 +227,29 @@ ${modeList}
 
 ## Memory Integration
 
-Use memory commands to persist context across SPARC sessions:
+### Using MCP Tools (Preferred)
+\`\`\`javascript
+// Store specifications
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "spec_auth",
+  value: "OAuth2 + JWT requirements",
+  namespace: "spec"
+}
+
+// Store architectural decisions
+mcp__claude-flow__memory_usage {
+  action: "store",
+  key: "arch_decisions",
+  value: "Microservices with API Gateway",
+  namespace: "architecture"
+}
+\`\`\`
+
+### Using NPX CLI (Fallback)
 \`\`\`bash
 # Store specifications
-./claude-flow memory store "spec_auth" "OAuth2 + JWT requirements" --namespace spec
+npx claude-flow memory store "spec_auth" "OAuth2 + JWT requirements" --namespace spec
 
 # Store architectural decisions
 ./claude-flow memory store "arch_api" "RESTful microservices design" --namespace arch