claude-flow-novice 2.0.4 → 2.0.5

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

@@ -1,1084 +1,1271 @@
 // init/index.js - Initialize Claude Code integration files
-import { printSuccess, printError, printWarning } from "../../utils.js";
-import { existsSync } from "fs";
-import { promises as fs } from "fs";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
-import process from "process";
-import { spawn, execSync } from "child_process";
+import { printSuccess, printError, printWarning, exit } from '../../utils.js';
+import { existsSync } from 'fs';
+import { promises as fs } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import process from 'process';
+import { spawn, execSync } from 'child_process';
+import { promisify } from 'util';
+
 // Helper to replace Deno.Command
 function runCommand(command, args, options = {}) {
-    return new Promise((resolve, reject)=>{
-        const child = spawn(command, args, {
-            cwd: options.cwd,
-            env: {
-                ...process.env,
-                ...options.env
-            },
-            stdio: options.stdout === 'inherit' ? 'inherit' : 'pipe'
-        });
-        let stdout = '';
-        let stderr = '';
-        if (options.stdout !== 'inherit') {
-            child.stdout.on('data', (data)=>{
-                stdout += data;
-            });
-            child.stderr.on('data', (data)=>{
-                stderr += data;
-            });
-        }
-        child.on('close', (code)=>{
-            if (code === 0) {
-                resolve({
-                    success: true,
-                    code,
-                    stdout,
-                    stderr
-                });
-            } else {
-                reject(new Error(`Command failed with exit code ${code}`));
-            }
-        });
-        child.on('error', reject);
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: options.stdout === 'inherit' ? 'inherit' : 'pipe',
     });
+
+    let stdout = '';
+    let stderr = '';
+
+    if (options.stdout !== 'inherit') {
+      child.stdout.on('data', (data) => {
+        stdout += data;
+      });
+      child.stderr.on('data', (data) => {
+        stderr += data;
+      });
+    }
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ success: true, code, stdout, stderr });
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
 }
-import { createLocalExecutable } from "./executable-wrapper.js";
-import { createSparcStructureManually } from "./sparc-structure.js";
-import { createClaudeSlashCommands } from "./claude-commands/slash-commands.js";
-import { createOptimizedClaudeSlashCommands } from "./claude-commands/optimized-slash-commands.js";
-import { copyTemplates } from "./template-copier.js";
-import { copyRevisedTemplates, validateTemplatesExist } from "./copy-revised-templates.js";
-import { copyAgentFiles, createAgentDirectories, validateAgentSystem, copyCommandFiles } from "./agent-copier.js";
-import { showInitHelp } from "./help.js";
-import { batchInitCommand, batchInitFromConfig, validateBatchOptions } from "./batch-init.js";
-import { ValidationSystem, runFullValidation } from "./validation/index.js";
-import { RollbackSystem, createAtomicOperation } from "./rollback/index.js";
-import { createEnhancedSettingsJson, createWrapperScript, createCommandDoc, createHelperScript, COMMAND_STRUCTURE } from "./templates/enhanced-templates.js";
-import { getIsolatedNpxEnv } from "../../../utils/npx-isolated-cache.js";
-import { updateGitignore } from "./gitignore-updater.js";
-import { createFullMemoryBankMd, createMinimalMemoryBankMd } from "./templates/memory-bank-md.js";
-import { createFullCoordinationMd, createMinimalCoordinationMd } from "./templates/coordination-md.js";
-import { createAgentsReadme, createSessionsReadme } from "./templates/readme-files.js";
-import { initializeHiveMind, getHiveMindStatus, rollbackHiveMindInit } from "./hive-mind-init.js";
+import { createLocalExecutable } from './executable-wrapper.js';
+import { createSparcStructureManually } from './sparc-structure.js';
+import { createClaudeSlashCommands } from './claude-commands/slash-commands.js';
+import { createOptimizedClaudeSlashCommands } from './claude-commands/optimized-slash-commands.js';
+import { copyTemplates } from './template-copier.js';
+import { copyRevisedTemplates, validateTemplatesExist } from './copy-revised-templates.js';
+import {
+  copyAgentFiles,
+  createAgentDirectories,
+  validateAgentSystem,
+  copyCommandFiles,
+} from './agent-copier.js';
+import { showInitHelp } from './help.js';
+import { batchInitCommand, batchInitFromConfig, validateBatchOptions } from './batch-init.js';
+import { ValidationSystem, runFullValidation } from './validation/index.js';
+import { RollbackSystem, createAtomicOperation } from './rollback/index.js';
+import {
+  createEnhancedClaudeMd,
+  createEnhancedSettingsJson,
+  createWrapperScript,
+  createCommandDoc,
+  createHelperScript,
+  COMMAND_STRUCTURE,
+} from './templates/enhanced-templates.js';
+import { getIsolatedNpxEnv } from '../../../utils/npx-isolated-cache.js';
+import { updateGitignore, needsGitignoreUpdate } from './gitignore-updater.js';
+import {
+  createVerificationClaudeMd,
+  createVerificationSettingsJson,
+} from './templates/verification-claude-md.js';
+import { createFullMemoryBankMd, createMinimalMemoryBankMd } from './templates/memory-bank-md.js';
+import {
+  createFullCoordinationMd,
+  createMinimalCoordinationMd,
+} from './templates/coordination-md.js';
+import { createAgentsReadme, createSessionsReadme } from './templates/readme-files.js';
+import { initializeHiveMind, getHiveMindStatus, rollbackHiveMindInit } from './hive-mind-init.js';
+
 // Get the directory path of this module for resolving template files
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+
 /**
  * Read the CLAUDE.md template file
  * @returns {Promise<string>} The template content
- */ async function readClaudeMdTemplate() {
-    // In source: templates/CLAUDE.md
-    // In dist: the files are copied directly to init/ directory (not templates/)
-    const possiblePaths = [
-        join(__dirname, 'templates', 'CLAUDE.md'),
-        join(__dirname, 'CLAUDE.md')
-    ];
-    for (const templatePath of possiblePaths){
-        try {
-            const content = await fs.readFile(templatePath, 'utf8');
-            console.log(`✅ Using CLAUDE.md template from: ${templatePath}`);
-            return content;
-        } catch (error) {
-            continue;
-        }
+ */
+async function readClaudeMdTemplate() {
+  // In source: templates/CLAUDE.md
+  // In dist: the files are copied directly to init/ directory (not templates/)
+  const possiblePaths = [
+    join(__dirname, 'templates', 'CLAUDE.md'),  // Source location
+    join(__dirname, 'CLAUDE.md'),               // Dist location (files copied directly)
+  ];
+
+  for (const templatePath of possiblePaths) {
+    try {
+      const content = await fs.readFile(templatePath, 'utf8');
+      console.log(`✅ Using CLAUDE.md template from: ${templatePath}`);
+      return content;
+    } catch (error) {
+      // Try next path
+      continue;
     }
-    // If template not found, throw error instead of falling back
-    throw new Error('CLAUDE.md template file not found! Please ensure templates are included in the build.');
+  }
+
+  // If template not found, throw error instead of falling back
+  throw new Error('CLAUDE.md template file not found! Please ensure templates are included in the build.');
 }
+
 /**
  * Check if Claude Code CLI is installed
- */ function isClaudeCodeInstalled() {
-    try {
-        execSync('which claude', {
-            stdio: 'ignore'
-        });
-        return true;
-    } catch  {
-        return false;
-    }
+ */
+function isClaudeCodeInstalled() {
+  try {
+    execSync('which claude', { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
 }
+
 /**
  * Set up MCP servers in Claude Code (Legacy - replaced by bulletproof system)
- */ async function setupMcpServers(dryRun1 = false) {
-    console.log('\n🔌 Setting up MCP servers for Claude Code...');
-    const servers = [
-        {
-            name: 'claude-flow-novice',
-            command: 'node dist/mcp/mcp-server-sdk.js',
-            description: 'Claude Flow Novice MCP server with 30 essential tools'
-        }
-    ];
-    for (const server of servers){
-        try {
-            if (!dryRun1) {
-                console.log(`  🔄 Adding ${server.name}...`);
-                execSync(`claude mcp add ${server.name} ${server.command}`, {
-                    stdio: 'inherit'
-                });
-                console.log(`  ✅ Added ${server.name} - ${server.description}`);
-            } else {
-                console.log(`  [DRY RUN] Would add ${server.name} - ${server.description}`);
-            }
-        } catch (err) {
-            console.log(`  ⚠️  Failed to add ${server.name}: ${err.message}`);
-            console.log(`     You can add it manually with: claude mcp add ${server.name} ${server.command}`);
-        }
+ */
+async function setupMcpServers(dryRun = false) {
+  console.log('\n🔌 Setting up MCP servers for Claude Code...');
+
+  const servers = [
+    {
+      name: 'claude-flow-novice',
+      command: 'node dist/mcp/mcp-server-sdk.js',
+      description: 'Claude Flow Novice MCP server with 30 essential tools',
+    },
+  ];
+
+  for (const server of servers) {
+    try {
+      if (!dryRun) {
+        console.log(`  🔄 Adding ${server.name}...`);
+        execSync(`claude mcp add ${server.name} ${server.command}`, { stdio: 'inherit' });
+        console.log(`  ✅ Added ${server.name} - ${server.description}`);
+      } else {
+        console.log(`  [DRY RUN] Would add ${server.name} - ${server.description}`);
+      }
+    } catch (err) {
+      console.log(`  ⚠️  Failed to add ${server.name}: ${err.message}`);
+      console.log(
+        `     You can add it manually with: claude mcp add ${server.name} ${server.command}`,
+      );
     }
-    if (!dryRun1) {
-        console.log('\n  📋 Verifying MCP servers...');
-        try {
-            execSync('claude mcp list', {
-                stdio: 'inherit'
-            });
-        } catch (err) {
-            console.log('  ⚠️  Could not verify MCP servers');
-        }
+  }
+
+  if (!dryRun) {
+    console.log('\n  📋 Verifying MCP servers...');
+    try {
+      execSync('claude mcp list', { stdio: 'inherit' });
+    } catch (err) {
+      console.log('  ⚠️  Could not verify MCP servers');
     }
+  }
 }
+
 /**
  * Bulletproof MCP setup using the new configuration manager
- */ async function setupBulletproofMcp(options = {}) {
-    console.log('\n🛡️  Setting up bulletproof MCP configuration...');
-    try {
-        // Import the MCP configuration manager
-        const { enhancedMcpInit } = await import("../../mcp/mcp-config-manager.js");
-        const result = await enhancedMcpInit({
-            verbose: options.verbose || false,
-            autoFix: options.autoFix !== false,
-            dryRun: options.dryRun || false,
-            enhancedUx: true,
-            showEducation: options.showEducation || false // Show educational content for first-time users
+ */
+async function setupBulletproofMcp(options = {}) {
+  console.log('\n🛡️  Setting up bulletproof MCP configuration...');
+
+  try {
+    // Import the MCP configuration manager
+    const { enhancedMcpInit } = await import('../../mcp/mcp-config-manager.js');
+
+    const result = await enhancedMcpInit({
+      verbose: options.verbose || false,
+      autoFix: options.autoFix !== false, // Default to true
+      dryRun: options.dryRun || false,
+      enhancedUx: true, // Enable enhanced user experience
+      showEducation: options.showEducation || false // Show educational content for first-time users
+    });
+
+    if (result.success) {
+      console.log('✅ Bulletproof MCP configuration completed successfully');
+
+      // Display additional success information
+      if (result.details) {
+        console.log(`   • Issues Fixed: ${result.details.issuesFixed || 0}`);
+        console.log(`   • Health Score: ${result.details.healthScore || 'N/A'}/100`);
+        console.log(`   • Duration: ${result.duration || 'N/A'}ms`);
+      }
+
+      return true;
+    } else {
+      console.log(`⚠️  MCP configuration had issues: ${result.error}`);
+
+      // Display recovery information if available
+      if (result.rollbackAvailable) {
+        console.log('   🔄 Automatic rollback was performed');
+      }
+
+      if (result.recovery && result.recovery.recommendedActions) {
+        console.log('\n   🛠️ Recommended actions:');
+        result.recovery.recommendedActions.slice(0, 3).forEach((action, i) => {
+          console.log(`     ${i + 1}. ${action}`);
         });
-        if (result.success) {
-            console.log('✅ Bulletproof MCP configuration completed successfully');
-            // Display additional success information
-            if (result.details) {
-                console.log(`   • Issues Fixed: ${result.details.issuesFixed || 0}`);
-                console.log(`   • Health Score: ${result.details.healthScore || 'N/A'}/100`);
-                console.log(`   • Duration: ${result.duration || 'N/A'}ms`);
-            }
-            return true;
-        } else {
-            console.log(`⚠️  MCP configuration had issues: ${result.error}`);
-            // Display recovery information if available
-            if (result.rollbackAvailable) {
-                console.log('   🔄 Automatic rollback was performed');
-            }
-            if (result.recovery && result.recovery.recommendedActions) {
-                console.log('\n   🛠️ Recommended actions:');
-                result.recovery.recommendedActions.slice(0, 3).forEach((action, i)=>{
-                    console.log(`     ${i + 1}. ${action}`);
-                });
-            }
-            return false;
-        }
-    } catch (error) {
-        console.log(`⚠️  Bulletproof MCP setup failed: ${error.message}`);
-        console.log('     This may be due to missing dependencies or system configuration.');
-        // Check if it's a dependency issue
-        if (error.message.includes('Cannot find module') || error.message.includes('import')) {
-            console.log('     💡 Try installing dependencies: npm install');
-        }
-        console.log('     📞 Falling back to legacy MCP setup...');
-        // Fallback to legacy setup
-        await setupMcpServers(options.dryRun);
-        return false;
+      }
+
+      return false;
+    }
+  } catch (error) {
+    console.log(`⚠️  Bulletproof MCP setup failed: ${error.message}`);
+    console.log('     This may be due to missing dependencies or system configuration.');
+
+    // Check if it's a dependency issue
+    if (error.message.includes('Cannot find module') || error.message.includes('import')) {
+      console.log('     💡 Try installing dependencies: npm install');
     }
+
+    console.log('     📞 Falling back to legacy MCP setup...');
+
+    // Fallback to legacy setup
+    await setupMcpServers(options.dryRun);
+    return false;
+  }
 }
+
 export async function initCommand(subArgs, flags) {
-    // Show help if requested
-    if (flags.help || flags.h || subArgs.includes('--help') || subArgs.includes('-h')) {
-        showInitHelp();
-        return;
-    }
-    // Check for verification flags first
-    const hasVerificationFlags = subArgs.includes('--verify') || subArgs.includes('--pair') || flags.verify || flags.pair;
-    // Flow-nexus mode removed
-    // Default to enhanced Claude Flow v2 init unless other modes are specified
-    // Use --basic flag for old behavior, or verification flags for verification mode
-    if (!flags.basic && !flags.minimal && !flags.sparc && !hasVerificationFlags) {
-        return await enhancedClaudeFlowInit(flags, subArgs);
-    }
-    // Check for validation and rollback commands
-    if (subArgs.includes('--validate') || subArgs.includes('--validate-only')) {
-        return handleValidationCommand(subArgs, flags);
-    }
-    if (subArgs.includes('--rollback')) {
-        return handleRollbackCommand(subArgs, flags);
+  // Show help if requested
+  if (flags.help || flags.h || subArgs.includes('--help') || subArgs.includes('-h')) {
+    showInitHelp();
+    return;
+  }
+
+  // Check for verification flags first
+  const hasVerificationFlags =
+    subArgs.includes('--verify') || subArgs.includes('--pair') || flags.verify || flags.pair;
+
+  // Flow-nexus mode removed
+
+  // Default to enhanced Claude Flow v2 init unless other modes are specified
+  // Use --basic flag for old behavior, or verification flags for verification mode
+  if (!flags.basic && !flags.minimal && !flags.sparc && !hasVerificationFlags) {
+    return await enhancedClaudeFlowInit(flags, subArgs);
+  }
+
+  // Check for validation and rollback commands
+  if (subArgs.includes('--validate') || subArgs.includes('--validate-only')) {
+    return handleValidationCommand(subArgs, flags);
+  }
+
+  if (subArgs.includes('--rollback')) {
+    return handleRollbackCommand(subArgs, flags);
+  }
+
+  if (subArgs.includes('--list-backups')) {
+    return handleListBackups(subArgs, flags);
+  }
+
+  // Check for batch operations
+  const batchInitFlag = flags['batch-init'] || subArgs.includes('--batch-init');
+  const configFlag = flags.config || subArgs.includes('--config');
+
+  if (batchInitFlag || configFlag) {
+    return handleBatchInit(subArgs, flags);
+  }
+
+  // Parse init options
+  const initForce = subArgs.includes('--force') || subArgs.includes('-f') || flags.force;
+  const initMinimal = subArgs.includes('--minimal') || subArgs.includes('-m') || flags.minimal;
+  const initSparc = flags.roo || (subArgs && subArgs.includes('--roo')); // SPARC only with --roo flag
+  const initDryRun = subArgs.includes('--dry-run') || subArgs.includes('-d') || flags.dryRun;
+  const initOptimized = initSparc && initForce; // Use optimized templates when both flags are present
+  const selectedModes = flags.modes ? flags.modes.split(',') : null; // Support selective mode initialization
+
+  // Check for verification and pair programming flags
+  const initVerify = subArgs.includes('--verify') || flags.verify;
+  const initPair = subArgs.includes('--pair') || flags.pair;
+
+  // Get the actual working directory (where the command was run from)
+  // Use PWD environment variable which preserves the original directory
+  const workingDir = process.env.PWD || cwd();
+  console.log(`📁 Initializing in: ${workingDir}`);
+
+  // Change to the working directory to ensure all file operations happen there
+  try {
+    process.chdir(workingDir);
+  } catch (err) {
+    printWarning(`Could not change to directory ${workingDir}: ${err.message}`);
+  }
+
+  try {
+    printSuccess('Initializing Claude Code integration files...');
+
+    // Check if files already exist in the working directory
+    const files = ['CLAUDE.md', 'memory-bank.md', 'coordination.md'];
+    const existingFiles = [];
+
+    for (const file of files) {
+      try {
+        await fs.stat(`${workingDir}/${file}`);
+        existingFiles.push(file);
+      } catch {
+        // File doesn't exist, which is what we want
+      }
     }
-    if (subArgs.includes('--list-backups')) {
-        return handleListBackups(subArgs, flags);
+
+    if (existingFiles.length > 0 && !initForce) {
+      printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
+      console.log('Use --force to overwrite existing files');
+      return;
     }
-    // Check for batch operations
-    const batchInitFlag = flags['batch-init'] || subArgs.includes('--batch-init');
-    const configFlag = flags.config || subArgs.includes('--config');
-    if (batchInitFlag || configFlag) {
-        return handleBatchInit(subArgs, flags);
+
+    // Use template copier to copy all template files
+    const templateOptions = {
+      sparc: initSparc,
+      minimal: initMinimal,
+      optimized: initOptimized,
+      dryRun: initDryRun,
+      force: initForce,
+      selectedModes: selectedModes,
+      verify: initVerify,
+      pair: initPair,
+    };
+
+    // If verification flags are set, always use generated templates for CLAUDE.md and settings.json
+    if (initVerify || initPair) {
+      console.log('  📁 Creating verification-focused configuration...');
+
+      // Create verification CLAUDE.md
+      if (!initDryRun) {
+        const { createVerificationClaudeMd, createVerificationSettingsJson } = await import(
+          './templates/verification-claude-md.js'
+        );
+        await fs.writeFile(`${workingDir}/CLAUDE.md`, createVerificationClaudeMd(), 'utf8');
+
+        // Create .claude directory and settings
+        await fs.mkdir(`${workingDir}/.claude`, { recursive: true });
+        await fs.writeFile(
+          `${workingDir}/.claude/settings.json`,
+          createVerificationSettingsJson(),
+          'utf8',
+        );
+        console.log('  ✅ Created verification-focused CLAUDE.md and settings.json');
+      } else {
+        console.log('  [DRY RUN] Would create verification-focused CLAUDE.md and settings.json');
+      }
+
+      // Copy other template files from repository if available
+      const validation = validateTemplatesExist();
+      if (validation.valid) {
+        const revisedResults = await copyRevisedTemplates(workingDir, {
+          force: initForce,
+          dryRun: initDryRun,
+          verbose: false,
+          sparc: initSparc,
+        });
+      }
+
+      // Also create standard memory and coordination files
+      const copyResults = await copyTemplates(workingDir, {
+        ...templateOptions,
+        skipClaudeMd: true, // Don't overwrite the verification CLAUDE.md
+        skipSettings: true, // Don't overwrite the verification settings.json
+      });
+    } else {
+      // Standard template copying logic
+      const validation = validateTemplatesExist();
+      if (validation.valid) {
+        console.log('  📁 Copying revised template files...');
+        const revisedResults = await copyRevisedTemplates(workingDir, {
+          force: initForce,
+          dryRun: initDryRun,
+          verbose: true,
+          sparc: initSparc,
+        });
+
+        if (revisedResults.success) {
+          console.log(`  ✅ Copied ${revisedResults.copiedFiles.length} template files`);
+          if (revisedResults.skippedFiles.length > 0) {
+            console.log(`  ⏭️  Skipped ${revisedResults.skippedFiles.length} existing files`);
+          }
+        } else {
+          console.log('  ⚠️  Some template files could not be copied:');
+          revisedResults.errors.forEach((err) => console.log(`    - ${err}`));
+        }
+      } else {
+        // Fall back to generated templates
+        console.log('  ⚠️  Revised templates not available, using generated templates');
+        const copyResults = await copyTemplates(workingDir, templateOptions);
+
+        if (!copyResults.success) {
+          printError('Failed to copy templates:');
+          copyResults.errors.forEach((err) => console.log(`  ❌ ${err}`));
+          return;
+        }
+      }
     }
-    // Parse init options
-    const initForce = subArgs.includes('--force') || subArgs.includes('-f') || flags.force;
-    const initMinimal = subArgs.includes('--minimal') || subArgs.includes('-m') || flags.minimal;
-    const initSparc = flags.roo || subArgs && subArgs.includes('--roo'); // SPARC only with --roo flag
-    const initDryRun = subArgs.includes('--dry-run') || subArgs.includes('-d') || flags.dryRun;
-    const initOptimized = initSparc && initForce; // Use optimized templates when both flags are present
-    const selectedModes = flags.modes ? flags.modes.split(',') : null; // Support selective mode initialization
-    // Check for verification and pair programming flags
-    const initVerify = subArgs.includes('--verify') || flags.verify;
-    const initPair = subArgs.includes('--pair') || flags.pair;
-    // Get the actual working directory (where the command was run from)
-    // Use PWD environment variable which preserves the original directory
-    const workingDir = process.env.PWD || cwd();
-    console.log(`📁 Initializing in: ${workingDir}`);
-    // Change to the working directory to ensure all file operations happen there
-    try {
-        process.chdir(workingDir);
-    } catch (err) {
-        printWarning(`Could not change to directory ${workingDir}: ${err.message}`);
+
+    // Agent setup moved to end of function where execution is guaranteed
+
+    // Directory structure is created by template copier
+
+    // SPARC files are created by template copier when --sparc flag is used
+
+    // Memory README files and persistence database are created by template copier
+
+    // Create local claude-flow-novice executable wrapper
+    if (!initDryRun) {
+      await createLocalExecutable(workingDir);
+    } else {
+      console.log('  [DRY RUN] Would create local claude-flow-novice executable wrapper');
     }
-    try {
-        printSuccess('Initializing Claude Code integration files...');
-        // Check if files already exist in the working directory
-        const files = [
-            'CLAUDE.md',
-            'memory-bank.md',
-            'coordination.md'
-        ];
-        const existingFiles = [];
-        for (const file of files){
-            try {
-                await fs.stat(`${workingDir}/${file}`);
-                existingFiles.push(file);
-            } catch  {
-            // File doesn't exist, which is what we want
-            }
+
+    // SPARC initialization
+    if (initSparc) {
+      console.log('\n🚀 Initializing SPARC development environment...');
+
+      if (initDryRun) {
+        console.log('  [DRY RUN] Would run: npx -y create-sparc init --force');
+        console.log('  [DRY RUN] Would create SPARC environment with all modes');
+        console.log(
+          '  [DRY RUN] Would create Claude slash commands' +
+            (initOptimized ? ' (Batchtools-optimized)' : ''),
+        );
+        if (selectedModes) {
+          console.log(
+            `  [DRY RUN] Would create commands for selected modes: ${selectedModes.join(', ')}`,
+          );
         }
-        if (existingFiles.length > 0 && !initForce) {
-            printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
-            console.log('Use --force to overwrite existing files');
-            return;
+      } else {
+        // Check if create-sparc exists and run it
+        let sparcInitialized = false;
+        try {
+          // Use isolated NPX cache to prevent concurrent conflicts
+          console.log('  🔄 Running: npx -y create-sparc init --force');
+          const createSparcResult = await runCommand(
+            'npx',
+            ['-y', 'create-sparc', 'init', '--force'],
+            {
+              cwd: workingDir,
+              stdout: 'inherit',
+              stderr: 'inherit',
+              env: getIsolatedNpxEnv({
+                PWD: workingDir,
+              }),
+            },
+          );
+
+          if (createSparcResult.success) {
+            console.log('  ✅ SPARC environment initialized successfully');
+            sparcInitialized = true;
+          } else {
+            printWarning('create-sparc failed, creating basic SPARC structure manually...');
+
+            // Fallback: create basic SPARC structure manually
+            await createSparcStructureManually();
+            sparcInitialized = true; // Manual creation still counts as initialized
+          }
+        } catch (err) {
+          printWarning('create-sparc not available, creating basic SPARC structure manually...');
+
+          // Fallback: create basic SPARC structure manually
+          await createSparcStructureManually();
+          sparcInitialized = true; // Manual creation still counts as initialized
         }
-        // Use template copier to copy all template files
-        const templateOptions = {
-            sparc: initSparc,
-            minimal: initMinimal,
-            optimized: initOptimized,
-            dryRun: initDryRun,
-            force: initForce,
-            selectedModes: selectedModes,
-            verify: initVerify,
-            pair: initPair
-        };
-        // If verification flags are set, always use generated templates for CLAUDE.md and settings.json
-        if (initVerify || initPair) {
-            console.log('  📁 Creating verification-focused configuration...');
-            // Create verification CLAUDE.md
-            if (!initDryRun) {
-                const { createVerificationClaudeMd, createVerificationSettingsJson } = await import("./templates/verification-claude-md.js");
-                await fs.writeFile(`${workingDir}/CLAUDE.md`, createVerificationClaudeMd(), 'utf8');
-                // Create .claude directory and settings
-                await fs.mkdir(`${workingDir}/.claude`, {
-                    recursive: true
-                });
-                await fs.writeFile(`${workingDir}/.claude/settings.json`, createVerificationSettingsJson(), 'utf8');
-                console.log('  ✅ Created verification-focused CLAUDE.md and settings.json');
-            } else {
-                console.log('  [DRY RUN] Would create verification-focused CLAUDE.md and settings.json');
-            }
-            // Copy other template files from repository if available
-            const validation = validateTemplatesExist();
-            if (validation.valid) {
-                const revisedResults = await copyRevisedTemplates(workingDir, {
-                    force: initForce,
-                    dryRun: initDryRun,
-                    verbose: false,
-                    sparc: initSparc
-                });
-            }
-            // Also create standard memory and coordination files
-            const copyResults = await copyTemplates(workingDir, {
-                ...templateOptions,
-                skipClaudeMd: true,
-                skipSettings: true
-            });
-        } else {
-            // Standard template copying logic
-            const validation = validateTemplatesExist();
-            if (validation.valid) {
-                console.log('  📁 Copying revised template files...');
-                const revisedResults = await copyRevisedTemplates(workingDir, {
-                    force: initForce,
-                    dryRun: initDryRun,
-                    verbose: true,
-                    sparc: initSparc
-                });
-                if (revisedResults.success) {
-                    console.log(`  ✅ Copied ${revisedResults.copiedFiles.length} template files`);
-                    if (revisedResults.skippedFiles.length > 0) {
-                        console.log(`  ⏭️  Skipped ${revisedResults.skippedFiles.length} existing files`);
-                    }
-                } else {
-                    console.log('  ⚠️  Some template files could not be copied:');
-                    revisedResults.errors.forEach((err)=>console.log(`    - ${err}`));
-                }
+
+        // Always create Claude slash commands after SPARC initialization
+        if (sparcInitialized) {
+          try {
+            if (initOptimized) {
+              await createOptimizedClaudeSlashCommands(workingDir, selectedModes);
             } else {
-                // Fall back to generated templates
-                console.log('  ⚠️  Revised templates not available, using generated templates');
-                const copyResults = await copyTemplates(workingDir, templateOptions);
-                if (!copyResults.success) {
-                    printError('Failed to copy templates:');
-                    copyResults.errors.forEach((err)=>console.log(`  ❌ ${err}`));
-                    return;
-                }
+              await createClaudeSlashCommands(workingDir);
             }
+          } catch (err) {
+            // Legacy slash command creation - silently skip if it fails
+            // SPARC slash commands are already created successfully above
+          }
+        }
+      }
+    }
+
+    if (initDryRun) {
+      printSuccess("🔍 Dry run completed! Here's what would be created:");
+      console.log('\n📋 Summary of planned initialization:');
+      console.log(
+        `  • Configuration: ${initOptimized ? 'Batchtools-optimized SPARC' : initSparc ? 'SPARC-enhanced' : 'Standard'}`,
+      );
+      console.log(
+        `  • Template type: ${initOptimized ? 'Optimized for parallel processing' : 'Standard'}`,
+      );
+      console.log('  • Core files: CLAUDE.md, memory-bank.md, coordination.md');
+      console.log('  • Directory structure: memory/, coordination/, .claude/');
+      console.log('  • Local executable: ./claude-flow');
+      if (initSparc) {
+        console.log(
+          `  • Claude Code slash commands: ${selectedModes ? selectedModes.length : 'All'} SPARC mode commands`,
+        );
+        console.log('  • SPARC environment with all development modes');
+      }
+      if (initOptimized) {
+        console.log('  • Batchtools optimization: Enabled for parallel processing');
+        console.log('  • Performance enhancements: Smart batching, concurrent operations');
+      }
+      console.log('\n🚀 To proceed with initialization, run the same command without --dry-run');
+    } else {
+      printSuccess('🎉 Claude Code integration files initialized successfully!');
+
+      if (initOptimized) {
+        console.log('\n⚡ Batchtools Optimization Enabled!');
+        console.log('  • Parallel processing capabilities activated');
+        console.log('  • Performance improvements: 250-500% faster operations');
+        console.log('  • Smart batching and concurrent operations available');
+      }
+
+      console.log('\n📋 What was created:');
+      console.log(
+        `  ✅ CLAUDE.md (${initOptimized ? 'Batchtools-optimized' : initSparc ? 'SPARC-enhanced' : 'Standard configuration'})`,
+      );
+      console.log(
+        `  ✅ memory-bank.md (${initOptimized ? 'With parallel processing' : 'Standard memory system'})`,
+      );
+      console.log(
+        `  ✅ coordination.md (${initOptimized ? 'Enhanced with batchtools' : 'Standard coordination'})`,
+      );
+      console.log('  ✅ Directory structure with memory/ and coordination/');
+      console.log('  ✅ Local executable at ./claude-flow');
+      console.log('  ✅ Persistence database at memory/claude-flow-data.json');
+      console.log('  ✅ Agent system with 64 specialized agents in .claude/agents/');
+
+      if (initSparc) {
+        const modeCount = selectedModes ? selectedModes.length : '20+';
+        console.log(`  ✅ Claude Code slash commands (${modeCount} SPARC modes)`);
+        console.log('  ✅ Complete SPARC development environment');
+      }
+
+      console.log('\n🚀 Next steps:');
+      console.log('1. Review and customize the generated files for your project');
+      console.log("2. Run './claude-flow-novice start' to begin the orchestration system");
+      console.log("3. Use './claude-flow' instead of 'npx claude-flow' for all commands");
+      console.log("4. Use 'claude --dangerously-skip-permissions' for unattended operation");
+
+      if (initSparc) {
+        console.log(
+          '5. Use Claude Code slash commands: /sparc, /sparc-architect, /sparc-tdd, etc.',
+        );
+        console.log("6. Explore SPARC modes with './claude-flow-novice sparc modes'");
+        console.log('7. Try TDD workflow with \'./claude-flow-novice sparc tdd "your task"\'');
+
+        if (initOptimized) {
+          console.log('8. Use batchtools commands: /batchtools, /performance for optimization');
+          console.log('9. Enable parallel processing with --parallel flags');
+          console.log("10. Monitor performance with './claude-flow-novice performance monitor'");
         }
-        // Agent setup moved to end of function where execution is guaranteed
-        // Directory structure is created by template copier
-        // SPARC files are created by template copier when --sparc flag is used
-        // Memory README files and persistence database are created by template copier
-        // Create local claude-flow-novice executable wrapper
+      }
+
+      // Update .gitignore
+      const gitignoreResult = await updateGitignore(workingDir, initForce, initDryRun);
+      if (gitignoreResult.success) {
         if (!initDryRun) {
-            await createLocalExecutable(workingDir);
+          console.log(`  ✅ ${gitignoreResult.message}`);
         } else {
-            console.log('  [DRY RUN] Would create local claude-flow-novice executable wrapper');
+          console.log(`  ${gitignoreResult.message}`);
         }
-        // SPARC initialization
-        if (initSparc) {
-            console.log('\n🚀 Initializing SPARC development environment...');
-            if (initDryRun) {
-                console.log('  [DRY RUN] Would run: npx -y create-sparc init --force');
-                console.log('  [DRY RUN] Would create SPARC environment with all modes');
-                console.log('  [DRY RUN] Would create Claude slash commands' + (initOptimized ? ' (Batchtools-optimized)' : ''));
-                if (selectedModes) {
-                    console.log(`  [DRY RUN] Would create commands for selected modes: ${selectedModes.join(', ')}`);
-                }
-            } else {
-                // Check if create-sparc exists and run it
-                let sparcInitialized = false;
-                try {
-                    // Use isolated NPX cache to prevent concurrent conflicts
-                    console.log('  🔄 Running: npx -y create-sparc init --force');
-                    const createSparcResult = await runCommand('npx', [
-                        '-y',
-                        'create-sparc',
-                        'init',
-                        '--force'
-                    ], {
-                        cwd: workingDir,
-                        stdout: 'inherit',
-                        stderr: 'inherit',
-                        env: getIsolatedNpxEnv({
-                            PWD: workingDir
-                        })
-                    });
-                    if (createSparcResult.success) {
-                        console.log('  ✅ SPARC environment initialized successfully');
-                        sparcInitialized = true;
-                    } else {
-                        printWarning('create-sparc failed, creating basic SPARC structure manually...');
-                        // Fallback: create basic SPARC structure manually
-                        await createSparcStructureManually();
-                        sparcInitialized = true; // Manual creation still counts as initialized
-                    }
-                } catch (err) {
-                    printWarning('create-sparc not available, creating basic SPARC structure manually...');
-                    // Fallback: create basic SPARC structure manually
-                    await createSparcStructureManually();
-                    sparcInitialized = true; // Manual creation still counts as initialized
-                }
-                // Always create Claude slash commands after SPARC initialization
-                if (sparcInitialized) {
-                    try {
-                        if (initOptimized) {
-                            await createOptimizedClaudeSlashCommands(workingDir, selectedModes);
-                        } else {
-                            await createClaudeSlashCommands(workingDir);
-                        }
-                    } catch (err) {
-                    // Legacy slash command creation - silently skip if it fails
-                    // SPARC slash commands are already created successfully above
-                    }
-                }
-            }
+      } else {
+        console.log(`  ⚠️  ${gitignoreResult.message}`);
+      }
+
+      console.log('\n💡 Tips:');
+      console.log("  • Type '/' in Claude Code to see all available slash commands");
+      console.log("  • Use './claude-flow-novice status' to check system health");
+      console.log("  • Store important context with './claude-flow-novice memory store'");
+
+      if (initOptimized) {
+        console.log('  • Use --parallel flags for concurrent operations');
+        console.log('  • Enable batch processing for multiple related tasks');
+        console.log('  • Monitor performance with real-time metrics');
+      }
+
+      // Initialize hive-mind system for standard init
+      console.log('\n🧠 Initializing basic hive-mind system...');
+      try {
+        const hiveMindOptions = {
+          config: {
+            integration: {
+              claudeCode: { enabled: isClaudeCodeInstalled() },
+              mcpTools: { enabled: true },
+            },
+            monitoring: { enabled: false }, // Basic setup for standard init
+          },
+        };
+
+        const hiveMindResult = await initializeHiveMind(workingDir, hiveMindOptions, false);
+
+        if (hiveMindResult.success) {
+          console.log('  ✅ Basic hive-mind system initialized');
+          console.log('  💡 Use "npx claude-flow-novice hive-mind" for advanced features');
+        } else {
+          console.log(`  ⚠️  Hive-mind setup skipped: ${hiveMindResult.error}`);
         }
-        if (initDryRun) {
-            printSuccess("🔍 Dry run completed! Here's what would be created:");
-            console.log('\n📋 Summary of planned initialization:');
-            console.log(`  • Configuration: ${initOptimized ? 'Batchtools-optimized SPARC' : initSparc ? 'SPARC-enhanced' : 'Standard'}`);
-            console.log(`  • Template type: ${initOptimized ? 'Optimized for parallel processing' : 'Standard'}`);
-            console.log('  • Core files: CLAUDE.md, memory-bank.md, coordination.md');
-            console.log('  • Directory structure: memory/, coordination/, .claude/');
-            console.log('  • Local executable: ./claude-flow');
-            if (initSparc) {
-                console.log(`  • Claude Code slash commands: ${selectedModes ? selectedModes.length : 'All'} SPARC mode commands`);
-                console.log('  • SPARC environment with all development modes');
-            }
-            if (initOptimized) {
-                console.log('  • Batchtools optimization: Enabled for parallel processing');
-                console.log('  • Performance enhancements: Smart batching, concurrent operations');
-            }
-            console.log('\n🚀 To proceed with initialization, run the same command without --dry-run');
+      } catch (err) {
+        console.log(`  ⚠️  Hive-mind setup skipped: ${err.message}`);
+      }
+
+      // Check for Claude Code and set up MCP servers (always enabled by default)
+      if (!initDryRun && isClaudeCodeInstalled()) {
+        console.log('\n🔍 Claude Code CLI detected!');
+        const skipMcp = subArgs && subArgs.includes && subArgs.includes('--skip-mcp');
+
+        if (!skipMcp) {
+          // Use bulletproof MCP setup instead of legacy
+          const mcpSuccess = await setupBulletproofMcp({
+            verbose: false,
+            autoFix: true,
+            dryRun: initDryRun
+          });
+
+          if (!mcpSuccess) {
+            console.log('  💡 If you encounter issues, run: claude mcp remove claude-flow-novice -s local');
+          }
         } else {
-            printSuccess('🎉 Claude Code integration files initialized successfully!');
-            if (initOptimized) {
-                console.log('\n⚡ Batchtools Optimization Enabled!');
-                console.log('  • Parallel processing capabilities activated');
-                console.log('  • Performance improvements: 250-500% faster operations');
-                console.log('  • Smart batching and concurrent operations available');
-            }
-            console.log('\n📋 What was created:');
-            console.log(`  ✅ CLAUDE.md (${initOptimized ? 'Batchtools-optimized' : initSparc ? 'SPARC-enhanced' : 'Standard configuration'})`);
-            console.log(`  ✅ memory-bank.md (${initOptimized ? 'With parallel processing' : 'Standard memory system'})`);
-            console.log(`  ✅ coordination.md (${initOptimized ? 'Enhanced with batchtools' : 'Standard coordination'})`);
-            console.log('  ✅ Directory structure with memory/ and coordination/');
-            console.log('  ✅ Local executable at ./claude-flow');
-            console.log('  ✅ Persistence database at memory/claude-flow-data.json');
-            console.log('  ✅ Agent system with 64 specialized agents in .claude/agents/');
-            if (initSparc) {
-                const modeCount = selectedModes ? selectedModes.length : '20+';
-                console.log(`  ✅ Claude Code slash commands (${modeCount} SPARC modes)`);
-                console.log('  ✅ Complete SPARC development environment');
-            }
-            console.log('\n🚀 Next steps:');
-            console.log('1. Review and customize the generated files for your project');
-            console.log("2. Run './claude-flow-novice start' to begin the orchestration system");
-            console.log("3. Use './claude-flow' instead of 'npx claude-flow' for all commands");
-            console.log("4. Use 'claude --dangerously-skip-permissions' for unattended operation");
-            if (initSparc) {
-                console.log('5. Use Claude Code slash commands: /sparc, /sparc-architect, /sparc-tdd, etc.');
-                console.log("6. Explore SPARC modes with './claude-flow-novice sparc modes'");
-                console.log('7. Try TDD workflow with \'./claude-flow-novice sparc tdd "your task"\'');
-                if (initOptimized) {
-                    console.log('8. Use batchtools commands: /batchtools, /performance for optimization');
-                    console.log('9. Enable parallel processing with --parallel flags');
-                    console.log("10. Monitor performance with './claude-flow-novice performance monitor'");
-                }
-            }
-            // Update .gitignore
-            const gitignoreResult = await updateGitignore(workingDir, initForce, initDryRun);
-            if (gitignoreResult.success) {
-                if (!initDryRun) {
-                    console.log(`  ✅ ${gitignoreResult.message}`);
-                } else {
-                    console.log(`  ${gitignoreResult.message}`);
-                }
-            } else {
-                console.log(`  ⚠️  ${gitignoreResult.message}`);
-            }
-            console.log('\n💡 Tips:');
-            console.log("  • Type '/' in Claude Code to see all available slash commands");
-            console.log("  • Use './claude-flow-novice status' to check system health");
-            console.log("  • Store important context with './claude-flow-novice memory store'");
-            if (initOptimized) {
-                console.log('  • Use --parallel flags for concurrent operations');
-                console.log('  • Enable batch processing for multiple related tasks');
-                console.log('  • Monitor performance with real-time metrics');
-            }
-            // Initialize hive-mind system for standard init
-            console.log('\n🧠 Initializing basic hive-mind system...');
-            try {
-                const hiveMindOptions = {
-                    config: {
-                        integration: {
-                            claudeCode: {
-                                enabled: isClaudeCodeInstalled()
-                            },
-                            mcpTools: {
-                                enabled: true
-                            }
-                        },
-                        monitoring: {
-                            enabled: false
-                        }
-                    }
-                };
-                const hiveMindResult = await initializeHiveMind(workingDir, hiveMindOptions, false);
-                if (hiveMindResult.success) {
-                    console.log('  ✅ Basic hive-mind system initialized');
-                    console.log('  💡 Use "npx claude-flow-novice hive-mind" for advanced features');
-                } else {
-                    console.log(`  ⚠️  Hive-mind setup skipped: ${hiveMindResult.error}`);
-                }
-            } catch (err) {
-                console.log(`  ⚠️  Hive-mind setup skipped: ${err.message}`);
-            }
-            // Check for Claude Code and set up MCP servers (always enabled by default)
-            if (!initDryRun && isClaudeCodeInstalled()) {
-                console.log('\n🔍 Claude Code CLI detected!');
-                const skipMcp = subArgs && subArgs.includes && subArgs.includes('--skip-mcp');
-                if (!skipMcp) {
-                    // Use bulletproof MCP setup instead of legacy
-                    const mcpSuccess = await setupBulletproofMcp({
-                        verbose: false,
-                        autoFix: true,
-                        dryRun: initDryRun
-                    });
-                    if (!mcpSuccess) {
-                        console.log('  💡 If you encounter issues, run: claude mcp remove claude-flow-novice -s local');
-                    }
-                } else {
-                    console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
-                }
-            } else if (!initDryRun && !isClaudeCodeInstalled()) {
-                console.log('\n⚠️  Claude Code CLI not detected!');
-                console.log('  📥 Install with: npm install -g @anthropic-ai/claude-code');
-                console.log('  📋 Then add MCP servers manually with:');
-                console.log('     claude mcp add claude-flow-novice claude-flow-novice mcp start');
-                console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
-            // Flow-nexus integration removed
-            }
+          console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
         }
-    } catch (err) {
-        printError(`Failed to initialize files: ${err.message}`);
+      } else if (!initDryRun && !isClaudeCodeInstalled()) {
+        console.log('\n⚠️  Claude Code CLI not detected!');
+        console.log('  📥 Install with: npm install -g @anthropic-ai/claude-code');
+        console.log('  📋 Then add MCP servers manually with:');
+        console.log('     claude mcp add claude-flow-novice claude-flow-novice mcp start');
+        console.log('     claude mcp add ruv-swarm npx ruv-swarm mcp start');
+        // Flow-nexus integration removed
+      }
     }
+  } catch (err) {
+    printError(`Failed to initialize files: ${err.message}`);
+  }
 }
+
 // Handle batch initialization
 async function handleBatchInit(subArgs, flags) {
-    try {
-        // Options parsing from flags and subArgs
-        const options = {
-            parallel: !flags['no-parallel'] && flags.parallel !== false,
-            sparc: flags.sparc || flags.s,
-            minimal: flags.minimal || flags.m,
-            force: flags.force || flags.f,
-            maxConcurrency: flags['max-concurrent'] || 5,
-            progressTracking: true,
-            template: flags.template,
-            environments: flags.environments ? flags.environments.split(',').map((env)=>env.trim()) : [
-                'dev'
-            ]
-        };
-        // Validate options
-        const validationErrors = validateBatchOptions(options);
-        if (validationErrors.length > 0) {
-            printError('Batch options validation failed:');
-            validationErrors.forEach((error)=>console.error(`  - ${error}`));
-            return;
-        }
-        // Config file mode
-        if (flags.config) {
-            const configFile = flags.config;
-            printSuccess(`Loading batch configuration from: ${configFile}`);
-            const results = await batchInitFromConfig(configFile, options);
-            if (results) {
-                printSuccess('Batch initialization from config completed');
-            }
-            return;
-        }
-        // Batch init mode
-        if (flags['batch-init']) {
-            const projectsString = flags['batch-init'];
-            const projects = projectsString.split(',').map((project)=>project.trim());
-            if (projects.length === 0) {
-                printError('No projects specified for batch initialization');
-                return;
-            }
-            printSuccess(`Initializing ${projects.length} projects in batch mode`);
-            const results = await batchInitCommand(projects, options);
-            if (results) {
-                const successful = results.filter((r)=>r.success).length;
-                const failed = results.filter((r)=>!r.success).length;
-                if (failed === 0) {
-                    printSuccess(`All ${successful} projects initialized successfully`);
-                } else {
-                    printWarning(`${successful} projects succeeded, ${failed} failed`);
-                }
-            }
-            return;
+  try {
+    // Options parsing from flags and subArgs
+    const options = {
+      parallel: !flags['no-parallel'] && flags.parallel !== false,
+      sparc: flags.sparc || flags.s,
+      minimal: flags.minimal || flags.m,
+      force: flags.force || flags.f,
+      maxConcurrency: flags['max-concurrent'] || 5,
+      progressTracking: true,
+      template: flags.template,
+      environments: flags.environments
+        ? flags.environments.split(',').map((env) => env.trim())
+        : ['dev'],
+    };
+
+    // Validate options
+    const validationErrors = validateBatchOptions(options);
+    if (validationErrors.length > 0) {
+      printError('Batch options validation failed:');
+      validationErrors.forEach((error) => console.error(`  - ${error}`));
+      return;
+    }
+
+    // Config file mode
+    if (flags.config) {
+      const configFile = flags.config;
+      printSuccess(`Loading batch configuration from: ${configFile}`);
+      const results = await batchInitFromConfig(configFile, options);
+      if (results) {
+        printSuccess('Batch initialization from config completed');
+      }
+      return;
+    }
+
+    // Batch init mode
+    if (flags['batch-init']) {
+      const projectsString = flags['batch-init'];
+      const projects = projectsString.split(',').map((project) => project.trim());
+
+      if (projects.length === 0) {
+        printError('No projects specified for batch initialization');
+        return;
+      }
+
+      printSuccess(`Initializing ${projects.length} projects in batch mode`);
+      const results = await batchInitCommand(projects, options);
+
+      if (results) {
+        const successful = results.filter((r) => r.success).length;
+        const failed = results.filter((r) => !r.success).length;
+
+        if (failed === 0) {
+          printSuccess(`All ${successful} projects initialized successfully`);
+        } else {
+          printWarning(`${successful} projects succeeded, ${failed} failed`);
         }
-        printError('No batch operation specified. Use --batch-init <projects> or --config <file>');
-    } catch (err) {
-        printError(`Batch initialization failed: ${err.message}`);
+      }
+      return;
     }
+
+    printError('No batch operation specified. Use --batch-init <projects> or --config <file>');
+  } catch (err) {
+    printError(`Batch initialization failed: ${err.message}`);
+  }
 }
+
 /**
  * Enhanced initialization command with validation and rollback
- */ async function enhancedInitCommand(subArgs, flags) {
-    console.log('🛡️  Starting enhanced initialization with validation and rollback...');
-    // Store parameters to avoid scope issues in async context
-    const args = subArgs || [];
-    const options = flags || {};
-    // Get the working directory
-    const workingDir = process.env.PWD || process.cwd();
-    // Initialize systems
-    const rollbackSystem = new RollbackSystem(workingDir);
-    const validationSystem = new ValidationSystem(workingDir);
-    let atomicOp = null;
-    try {
-        // Parse options
-        const initOptions = {
-            force: args.includes('--force') || args.includes('-f') || options.force,
-            minimal: args.includes('--minimal') || args.includes('-m') || options.minimal,
-            sparc: args.includes('--sparc') || args.includes('-s') || options.sparc,
-            skipPreValidation: args.includes('--skip-pre-validation'),
-            skipBackup: args.includes('--skip-backup'),
-            validateOnly: args.includes('--validate-only')
-        };
-        // Phase 1: Pre-initialization validation
-        if (!initOptions.skipPreValidation) {
-            console.log('\n🔍 Phase 1: Pre-initialization validation...');
-            const preValidation = await validationSystem.validatePreInit(initOptions);
-            if (!preValidation.success) {
-                printError('Pre-initialization validation failed:');
-                preValidation.errors.forEach((error)=>console.error(`  ❌ ${error}`));
-                return;
-            }
-            if (preValidation.warnings.length > 0) {
-                printWarning('Pre-initialization warnings:');
-                preValidation.warnings.forEach((warning)=>console.warn(`  ⚠️  ${warning}`));
-            }
-            printSuccess('Pre-initialization validation passed');
-        }
-        // Stop here if validation-only mode
-        if (options.validateOnly) {
-            console.log('\n✅ Validation-only mode completed');
-            return;
-        }
-        // Phase 2: Create backup
-        if (!options.skipBackup) {
-            console.log('\n💾 Phase 2: Creating backup...');
-            const backupResult = await rollbackSystem.createPreInitBackup();
-            if (!backupResult.success) {
-                printError('Backup creation failed:');
-                backupResult.errors.forEach((error)=>console.error(`  ❌ ${error}`));
-                return;
-            }
-        }
-        // Phase 3: Initialize with atomic operations
-        console.log('\n🔧 Phase 3: Atomic initialization...');
-        atomicOp = createAtomicOperation(rollbackSystem, 'enhanced-init');
-        const atomicBegin = await atomicOp.begin();
-        if (!atomicBegin) {
-            printError('Failed to begin atomic operation');
-            return;
-        }
-        // Perform initialization steps with checkpoints
-        await performInitializationWithCheckpoints(rollbackSystem, options, workingDir, dryRun);
-        // Phase 4: Post-initialization validation
-        console.log('\n✅ Phase 4: Post-initialization validation...');
-        const postValidation = await validationSystem.validatePostInit();
-        if (!postValidation.success) {
-            printError('Post-initialization validation failed:');
-            postValidation.errors.forEach((error)=>console.error(`  ❌ ${error}`));
-            // Attempt automatic rollback
-            console.log('\n🔄 Attempting automatic rollback...');
-            await atomicOp.rollback();
-            printWarning('Initialization rolled back due to validation failure');
-            return;
-        }
-        // Phase 5: Configuration validation
-        console.log('\n🔧 Phase 5: Configuration validation...');
-        const configValidation = await validationSystem.validateConfiguration();
-        if (configValidation.warnings.length > 0) {
-            printWarning('Configuration warnings:');
-            configValidation.warnings.forEach((warning)=>console.warn(`  ⚠️  ${warning}`));
-        }
-        // Phase 6: Health checks
-        console.log('\n🏥 Phase 6: System health checks...');
-        const healthChecks = await validationSystem.runHealthChecks();
-        if (healthChecks.warnings.length > 0) {
-            printWarning('Health check warnings:');
-            healthChecks.warnings.forEach((warning)=>console.warn(`  ⚠️  ${warning}`));
-        }
-        // Commit atomic operation
-        await atomicOp.commit();
-        // Generate and display validation report
-        const fullValidation = await runFullValidation(workingDir, {
-            postInit: true,
-            skipPreInit: options.skipPreValidation
-        });
-        console.log('\n📊 Validation Report:');
-        console.log(fullValidation.report);
-        printSuccess('🎉 Enhanced initialization completed successfully!');
-        console.log('\n✨ Your SPARC environment is fully validated and ready to use');
-    } catch (error) {
-        printError(`Enhanced initialization failed: ${error.message}`);
-        // Attempt rollback if atomic operation is active
-        if (atomicOp && !atomicOp.completed) {
-            console.log('\n🔄 Performing emergency rollback...');
-            try {
-                await atomicOp.rollback();
-                printWarning('Emergency rollback completed');
-            } catch (rollbackError) {
-                printError(`Rollback also failed: ${rollbackError.message}`);
-            }
-        }
+ */
+async function enhancedInitCommand(subArgs, flags) {
+  console.log('🛡️  Starting enhanced initialization with validation and rollback...');
+
+  // Store parameters to avoid scope issues in async context
+  const args = subArgs || [];
+  const options = flags || {};
+
+  // Get the working directory
+  const workingDir = process.env.PWD || process.cwd();
+
+  // Initialize systems
+  const rollbackSystem = new RollbackSystem(workingDir);
+  const validationSystem = new ValidationSystem(workingDir);
+
+  let atomicOp = null;
+
+  try {
+    // Parse options
+    const initOptions = {
+      force: args.includes('--force') || args.includes('-f') || options.force,
+      minimal: args.includes('--minimal') || args.includes('-m') || options.minimal,
+      sparc: args.includes('--sparc') || args.includes('-s') || options.sparc,
+      skipPreValidation: args.includes('--skip-pre-validation'),
+      skipBackup: args.includes('--skip-backup'),
+      validateOnly: args.includes('--validate-only'),
+    };
+
+    // Phase 1: Pre-initialization validation
+    if (!initOptions.skipPreValidation) {
+      console.log('\n🔍 Phase 1: Pre-initialization validation...');
+      const preValidation = await validationSystem.validatePreInit(initOptions);
+
+      if (!preValidation.success) {
+        printError('Pre-initialization validation failed:');
+        preValidation.errors.forEach((error) => console.error(`  ❌ ${error}`));
+        return;
+      }
+
+      if (preValidation.warnings.length > 0) {
+        printWarning('Pre-initialization warnings:');
+        preValidation.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
+      }
+
+      printSuccess('Pre-initialization validation passed');
+    }
+
+    // Stop here if validation-only mode
+    if (options.validateOnly) {
+      console.log('\n✅ Validation-only mode completed');
+      return;
+    }
+
+    // Phase 2: Create backup
+    if (!options.skipBackup) {
+      console.log('\n💾 Phase 2: Creating backup...');
+      const backupResult = await rollbackSystem.createPreInitBackup();
+
+      if (!backupResult.success) {
+        printError('Backup creation failed:');
+        backupResult.errors.forEach((error) => console.error(`  ❌ ${error}`));
+        return;
+      }
+    }
+
+    // Phase 3: Initialize with atomic operations
+    console.log('\n🔧 Phase 3: Atomic initialization...');
+    atomicOp = createAtomicOperation(rollbackSystem, 'enhanced-init');
+
+    const atomicBegin = await atomicOp.begin();
+    if (!atomicBegin) {
+      printError('Failed to begin atomic operation');
+      return;
+    }
+
+    // Perform initialization steps with checkpoints
+    await performInitializationWithCheckpoints(rollbackSystem, options, workingDir, dryRun);
+
+    // Phase 4: Post-initialization validation
+    console.log('\n✅ Phase 4: Post-initialization validation...');
+    const postValidation = await validationSystem.validatePostInit();
+
+    if (!postValidation.success) {
+      printError('Post-initialization validation failed:');
+      postValidation.errors.forEach((error) => console.error(`  ❌ ${error}`));
+
+      // Attempt automatic rollback
+      console.log('\n🔄 Attempting automatic rollback...');
+      await atomicOp.rollback();
+      printWarning('Initialization rolled back due to validation failure');
+      return;
+    }
+
+    // Phase 5: Configuration validation
+    console.log('\n🔧 Phase 5: Configuration validation...');
+    const configValidation = await validationSystem.validateConfiguration();
+
+    if (configValidation.warnings.length > 0) {
+      printWarning('Configuration warnings:');
+      configValidation.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
+    }
+
+    // Phase 6: Health checks
+    console.log('\n🏥 Phase 6: System health checks...');
+    const healthChecks = await validationSystem.runHealthChecks();
+
+    if (healthChecks.warnings.length > 0) {
+      printWarning('Health check warnings:');
+      healthChecks.warnings.forEach((warning) => console.warn(`  ⚠️  ${warning}`));
+    }
+
+    // Commit atomic operation
+    await atomicOp.commit();
+
+    // Generate and display validation report
+    const fullValidation = await runFullValidation(workingDir, {
+      postInit: true,
+      skipPreInit: options.skipPreValidation,
+    });
+
+    console.log('\n📊 Validation Report:');
+    console.log(fullValidation.report);
+
+    printSuccess('🎉 Enhanced initialization completed successfully!');
+    console.log('\n✨ Your SPARC environment is fully validated and ready to use');
+  } catch (error) {
+    printError(`Enhanced initialization failed: ${error.message}`);
+
+    // Attempt rollback if atomic operation is active
+    if (atomicOp && !atomicOp.completed) {
+      console.log('\n🔄 Performing emergency rollback...');
+      try {
+        await atomicOp.rollback();
+        printWarning('Emergency rollback completed');
+      } catch (rollbackError) {
+        printError(`Rollback also failed: ${rollbackError.message}`);
+      }
     }
+  }
 }
+
 /**
  * Handle validation commands
- */ async function handleValidationCommand(subArgs, flags) {
-    const workingDir = process.env.PWD || process.cwd();
-    console.log('🔍 Running validation checks...');
-    const options = {
-        skipPreInit: subArgs.includes('--skip-pre-init'),
-        skipConfig: subArgs.includes('--skip-config'),
-        skipModeTest: subArgs.includes('--skip-mode-test'),
-        postInit: !subArgs.includes('--pre-init-only')
-    };
-    try {
-        const validationResults = await runFullValidation(workingDir, options);
-        console.log('\n📊 Validation Results:');
-        console.log(validationResults.report);
-        if (validationResults.success) {
-            printSuccess('✅ All validation checks passed');
-        } else {
-            printError('❌ Some validation checks failed');
-            process.exit(1);
-        }
-    } catch (error) {
-        printError(`Validation failed: ${error.message}`);
-        process.exit(1);
+ */
+async function handleValidationCommand(subArgs, flags) {
+  const workingDir = process.env.PWD || process.cwd();
+
+  console.log('🔍 Running validation checks...');
+
+  const options = {
+    skipPreInit: subArgs.includes('--skip-pre-init'),
+    skipConfig: subArgs.includes('--skip-config'),
+    skipModeTest: subArgs.includes('--skip-mode-test'),
+    postInit: !subArgs.includes('--pre-init-only'),
+  };
+
+  try {
+    const validationResults = await runFullValidation(workingDir, options);
+
+    console.log('\n📊 Validation Results:');
+    console.log(validationResults.report);
+
+    if (validationResults.success) {
+      printSuccess('✅ All validation checks passed');
+    } else {
+      printError('❌ Some validation checks failed');
+      process.exit(1);
     }
+  } catch (error) {
+    printError(`Validation failed: ${error.message}`);
+    process.exit(1);
+  }
 }
+
 /**
  * Handle rollback commands
- */ async function handleRollbackCommand(subArgs, flags) {
-    const workingDir = process.env.PWD || process.cwd();
-    const rollbackSystem = new RollbackSystem(workingDir);
-    try {
-        // Check for specific rollback options
-        if (subArgs.includes('--full')) {
-            console.log('🔄 Performing full rollback...');
-            const result = await rollbackSystem.performFullRollback();
-            if (result.success) {
-                printSuccess('Full rollback completed successfully');
-            } else {
-                printError('Full rollback failed:');
-                result.errors.forEach((error)=>console.error(`  ❌ ${error}`));
-            }
-        } else if (subArgs.includes('--partial')) {
-            const phaseIndex = subArgs.findIndex((arg)=>arg === '--phase');
-            if (phaseIndex !== -1 && subArgs[phaseIndex + 1]) {
-                const phase = subArgs[phaseIndex + 1];
-                console.log(`🔄 Performing partial rollback for phase: ${phase}`);
-                const result = await rollbackSystem.performPartialRollback(phase);
-                if (result.success) {
-                    printSuccess(`Partial rollback completed for phase: ${phase}`);
-                } else {
-                    printError(`Partial rollback failed for phase: ${phase}`);
-                    result.errors.forEach((error)=>console.error(`  ❌ ${error}`));
-                }
-            } else {
-                printError('Partial rollback requires --phase <phase-name>');
-            }
+ */
+async function handleRollbackCommand(subArgs, flags) {
+  const workingDir = process.env.PWD || process.cwd();
+  const rollbackSystem = new RollbackSystem(workingDir);
+
+  try {
+    // Check for specific rollback options
+    if (subArgs.includes('--full')) {
+      console.log('🔄 Performing full rollback...');
+      const result = await rollbackSystem.performFullRollback();
+
+      if (result.success) {
+        printSuccess('Full rollback completed successfully');
+      } else {
+        printError('Full rollback failed:');
+        result.errors.forEach((error) => console.error(`  ❌ ${error}`));
+      }
+    } else if (subArgs.includes('--partial')) {
+      const phaseIndex = subArgs.findIndex((arg) => arg === '--phase');
+      if (phaseIndex !== -1 && subArgs[phaseIndex + 1]) {
+        const phase = subArgs[phaseIndex + 1];
+        console.log(`🔄 Performing partial rollback for phase: ${phase}`);
+
+        const result = await rollbackSystem.performPartialRollback(phase);
+
+        if (result.success) {
+          printSuccess(`Partial rollback completed for phase: ${phase}`);
         } else {
-            // Interactive rollback point selection
-            const rollbackPoints = await rollbackSystem.listRollbackPoints();
-            if (rollbackPoints.rollbackPoints.length === 0) {
-                printWarning('No rollback points available');
-                return;
-            }
-            console.log('\n📋 Available rollback points:');
-            rollbackPoints.rollbackPoints.forEach((point, index)=>{
-                const date = new Date(point.timestamp).toLocaleString();
-                console.log(`  ${index + 1}. ${point.type} - ${date}`);
-            });
-            // For now, rollback to the most recent point
-            const latest = rollbackPoints.rollbackPoints[0];
-            if (latest) {
-                console.log(`\n🔄 Rolling back to: ${latest.type} (${new Date(latest.timestamp).toLocaleString()})`);
-                const result = await rollbackSystem.performFullRollback(latest.backupId);
-                if (result.success) {
-                    printSuccess('Rollback completed successfully');
-                } else {
-                    printError('Rollback failed');
-                }
-            }
+          printError(`Partial rollback failed for phase: ${phase}`);
+          result.errors.forEach((error) => console.error(`  ❌ ${error}`));
         }
-    } catch (error) {
-        printError(`Rollback operation failed: ${error.message}`);
+      } else {
+        printError('Partial rollback requires --phase <phase-name>');
+      }
+    } else {
+      // Interactive rollback point selection
+      const rollbackPoints = await rollbackSystem.listRollbackPoints();
+
+      if (rollbackPoints.rollbackPoints.length === 0) {
+        printWarning('No rollback points available');
+        return;
+      }
+
+      console.log('\n📋 Available rollback points:');
+      rollbackPoints.rollbackPoints.forEach((point, index) => {
+        const date = new Date(point.timestamp).toLocaleString();
+        console.log(`  ${index + 1}. ${point.type} - ${date}`);
+      });
+
+      // For now, rollback to the most recent point
+      const latest = rollbackPoints.rollbackPoints[0];
+      if (latest) {
+        console.log(
+          `\n🔄 Rolling back to: ${latest.type} (${new Date(latest.timestamp).toLocaleString()})`,
+        );
+        const result = await rollbackSystem.performFullRollback(latest.backupId);
+
+        if (result.success) {
+          printSuccess('Rollback completed successfully');
+        } else {
+          printError('Rollback failed');
+        }
+      }
     }
+  } catch (error) {
+    printError(`Rollback operation failed: ${error.message}`);
+  }
 }
+
 /**
  * Handle list backups command
- */ async function handleListBackups(subArgs, flags) {
-    const workingDir = process.env.PWD || process.cwd();
-    const rollbackSystem = new RollbackSystem(workingDir);
-    try {
-        const rollbackPoints = await rollbackSystem.listRollbackPoints();
-        console.log('\n📋 Rollback Points and Backups:');
-        if (rollbackPoints.rollbackPoints.length === 0) {
-            console.log('  No rollback points available');
-        } else {
-            console.log('\n🔄 Rollback Points:');
-            rollbackPoints.rollbackPoints.forEach((point, index)=>{
-                const date = new Date(point.timestamp).toLocaleString();
-                console.log(`  ${index + 1}. ${point.type} - ${date} (${point.backupId || 'No backup'})`);
-            });
-        }
-        if (rollbackPoints.checkpoints.length > 0) {
-            console.log('\n📍 Checkpoints:');
-            rollbackPoints.checkpoints.slice(-5).forEach((checkpoint, index)=>{
-                const date = new Date(checkpoint.timestamp).toLocaleString();
-                console.log(`  ${index + 1}. ${checkpoint.phase} - ${date} (${checkpoint.status})`);
-            });
-        }
-    } catch (error) {
-        printError(`Failed to list backups: ${error.message}`);
+ */
+async function handleListBackups(subArgs, flags) {
+  const workingDir = process.env.PWD || process.cwd();
+  const rollbackSystem = new RollbackSystem(workingDir);
+
+  try {
+    const rollbackPoints = await rollbackSystem.listRollbackPoints();
+
+    console.log('\n📋 Rollback Points and Backups:');
+
+    if (rollbackPoints.rollbackPoints.length === 0) {
+      console.log('  No rollback points available');
+    } else {
+      console.log('\n🔄 Rollback Points:');
+      rollbackPoints.rollbackPoints.forEach((point, index) => {
+        const date = new Date(point.timestamp).toLocaleString();
+        console.log(`  ${index + 1}. ${point.type} - ${date} (${point.backupId || 'No backup'})`);
+      });
+    }
+
+    if (rollbackPoints.checkpoints.length > 0) {
+      console.log('\n📍 Checkpoints:');
+      rollbackPoints.checkpoints.slice(-5).forEach((checkpoint, index) => {
+        const date = new Date(checkpoint.timestamp).toLocaleString();
+        console.log(`  ${index + 1}. ${checkpoint.phase} - ${date} (${checkpoint.status})`);
+      });
     }
+  } catch (error) {
+    printError(`Failed to list backups: ${error.message}`);
+  }
 }
+
 /**
  * Perform initialization with checkpoints
- */ async function performInitializationWithCheckpoints(rollbackSystem, options, workingDir, dryRun1 = false) {
-    const phases = [
-        {
-            name: 'file-creation',
-            action: ()=>createInitialFiles(options, workingDir, dryRun1)
-        },
-        {
-            name: 'directory-structure',
-            action: ()=>createDirectoryStructure(workingDir, dryRun1)
-        },
-        {
-            name: 'memory-setup',
-            action: ()=>setupMemorySystem(workingDir, dryRun1)
-        },
-        {
-            name: 'agent-system',
-            action: ()=>setupAgentSystem(workingDir, dryRun1, options)
-        },
-        {
-            name: 'mcp-config',
-            action: ()=>setupMcpConfiguration(workingDir, dryRun1)
-        },
-        {
-            name: 'hooks-system',
-            action: ()=>setupHooksSystem(workingDir, dryRun1)
-        },
-        {
-            name: 'coordination-setup',
-            action: ()=>setupCoordinationSystem(workingDir, dryRun1)
-        },
-        {
-            name: 'executable-creation',
-            action: ()=>createLocalExecutable(workingDir, dryRun1)
-        }
-    ];
-    if (options.sparc) {
-        phases.push({
-            name: 'sparc-init',
-            action: ()=>createSparcStructureManually()
-        }, {
-            name: 'claude-commands',
-            action: ()=>createClaudeSlashCommands(workingDir)
-        });
-    }
-    for (const phase of phases){
-        console.log(`  🔧 ${phase.name}...`);
-        // Create checkpoint before phase
-        await rollbackSystem.createCheckpoint(phase.name, {
-            timestamp: Date.now(),
-            phase: phase.name
-        });
-        try {
-            await phase.action();
-            console.log(`  ✅ ${phase.name} completed`);
-        } catch (error) {
-            console.error(`  ❌ ${phase.name} failed: ${error.message}`);
-            throw error;
-        }
+ */
+async function performInitializationWithCheckpoints(
+  rollbackSystem,
+  options,
+  workingDir,
+  dryRun = false,
+) {
+  const phases = [
+    { name: 'file-creation', action: () => createInitialFiles(options, workingDir, dryRun) },
+    { name: 'directory-structure', action: () => createDirectoryStructure(workingDir, dryRun) },
+    { name: 'memory-setup', action: () => setupMemorySystem(workingDir, dryRun) },
+    { name: 'agent-system', action: () => setupAgentSystem(workingDir, dryRun, options) },
+    { name: 'mcp-config', action: () => setupMcpConfiguration(workingDir, dryRun) },
+    { name: 'hooks-system', action: () => setupHooksSystem(workingDir, dryRun) },
+    { name: 'coordination-setup', action: () => setupCoordinationSystem(workingDir, dryRun) },
+    { name: 'executable-creation', action: () => createLocalExecutable(workingDir, dryRun) },
+  ];
+
+  if (options.sparc) {
+    phases.push(
+      { name: 'sparc-init', action: () => createSparcStructureManually() },
+      { name: 'claude-commands', action: () => createClaudeSlashCommands(workingDir) },
+    );
+  }
+
+  for (const phase of phases) {
+    console.log(`  🔧 ${phase.name}...`);
+
+    // Create checkpoint before phase
+    await rollbackSystem.createCheckpoint(phase.name, {
+      timestamp: Date.now(),
+      phase: phase.name,
+    });
+
+    try {
+      await phase.action();
+      console.log(`  ✅ ${phase.name} completed`);
+    } catch (error) {
+      console.error(`  ❌ ${phase.name} failed: ${error.message}`);
+      throw error;
     }
+  }
 }
+
 // Helper functions for atomic initialization
-async function createInitialFiles(options, workingDir, dryRun1 = false) {
-    if (!dryRun1) {
-        // Use template file instead of generation
-        const claudeMd = await readClaudeMdTemplate();
-        await fs.writeFile(`${workingDir}/CLAUDE.md`, claudeMd, 'utf8');
-        const memoryBankMd = options.minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
-        await fs.writeFile(`${workingDir}/memory-bank.md`, memoryBankMd, 'utf8');
-        const coordinationMd = options.minimal ? createMinimalCoordinationMd() : createFullCoordinationMd();
-        await fs.writeFile(`${workingDir}/coordination.md`, coordinationMd, 'utf8');
-    }
+async function createInitialFiles(options, workingDir, dryRun = false) {
+  if (!dryRun) {
+    // Use template file instead of generation
+    const claudeMd = await readClaudeMdTemplate();
+    await fs.writeFile(`${workingDir}/CLAUDE.md`, claudeMd, 'utf8');
+
+    const memoryBankMd = options.minimal ? createMinimalMemoryBankMd() : createFullMemoryBankMd();
+    await fs.writeFile(`${workingDir}/memory-bank.md`, memoryBankMd, 'utf8');
+
+    const coordinationMd = options.minimal
+      ? createMinimalCoordinationMd()
+      : createFullCoordinationMd();
+    await fs.writeFile(`${workingDir}/coordination.md`, coordinationMd, 'utf8');
+  }
 }
-async function createDirectoryStructure(workingDir, dryRun1 = false) {
-    const directories = [
-        'memory',
-        'memory/agents',
-        'memory/sessions',
-        'coordination',
-        'coordination/memory_bank',
-        'coordination/subtasks',
-        'coordination/orchestration',
-        '.claude',
-        '.claude/commands',
-        '.claude/logs'
-    ];
-    if (!dryRun1) {
-        for (const dir of directories){
-            await fs.mkdir(`${workingDir}/${dir}`, {
-                recursive: true
-            });
-        }
+
+async function createDirectoryStructure(workingDir, dryRun = false) {
+  const directories = [
+    'memory',
+    'memory/agents',
+    'memory/sessions',
+    'coordination',
+    'coordination/memory_bank',
+    'coordination/subtasks',
+    'coordination/orchestration',
+    '.claude',
+    '.claude/commands',
+    '.claude/logs',
+  ];
+
+  if (!dryRun) {
+    for (const dir of directories) {
+      await fs.mkdir(`${workingDir}/${dir}`, { recursive: true });
     }
+  }
 }
-async function setupMemorySystem(workingDir, dryRun1 = false) {
-    if (!dryRun1) {
-        const initialData = {
-            agents: [],
-            tasks: [],
-            lastUpdated: Date.now()
-        };
-        await fs.writeFile(`${workingDir}/memory/claude-flow-data.json`, JSON.stringify(initialData, null, 2), 'utf8');
-        await fs.writeFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme(), 'utf8');
-        await fs.writeFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme(), 'utf8');
-    }
+
+async function setupMemorySystem(workingDir, dryRun = false) {
+  if (!dryRun) {
+    const initialData = { agents: [], tasks: [], lastUpdated: Date.now() };
+    await fs.writeFile(
+      `${workingDir}/memory/claude-flow-data.json`,
+      JSON.stringify(initialData, null, 2),
+      'utf8',
+    );
+
+    await fs.writeFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme(), 'utf8');
+    await fs.writeFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme(), 'utf8');
+  }
 }
-async function setupAgentSystem(workingDir, dryRun1 = false, options = {}) {
-    if (!dryRun1) {
-        console.log('🤖 Setting up agent system...');
-        // Create agent directories
-        await createAgentDirectories(workingDir, dryRun1);
-        // Copy all agent files (80+ agents)
-        const agentResult = await copyAgentFiles(workingDir, {
-            force: options.force || false,
-            dryRun: dryRun1
-        });
-        if (agentResult.success) {
-            await validateAgentSystem(workingDir);
-            // Copy command files
-            const commandResult = await copyCommandFiles(workingDir, {
-                force: options.force || false,
-                dryRun: dryRun1
-            });
-            if (commandResult.success) {
-                console.log('  ✅ Agent system setup complete with 80+ specialized agents');
-            } else {
-                console.log('  ⚠️ Command system setup failed:', commandResult.error);
-            }
-        } else {
-            console.log('  ⚠️ Agent system setup failed:', agentResult.error);
-        }
+
+async function setupAgentSystem(workingDir, dryRun = false, options = {}) {
+  if (!dryRun) {
+    console.log('🤖 Setting up agent system...');
+
+    // Create agent directories
+    await createAgentDirectories(workingDir, dryRun);
+
+    // Copy all agent files (80+ agents)
+    const agentResult = await copyAgentFiles(workingDir, {
+      force: options.force || false,
+      dryRun: dryRun,
+    });
+
+    if (agentResult.success) {
+      await validateAgentSystem(workingDir);
+
+      // Copy command files
+      const commandResult = await copyCommandFiles(workingDir, {
+        force: options.force || false,
+        dryRun: dryRun,
+      });
+
+      if (commandResult.success) {
+        console.log('  ✅ Agent system setup complete with 80+ specialized agents');
+      } else {
+        console.log('  ⚠️ Command system setup failed:', commandResult.error);
+      }
+    } else {
+      console.log('  ⚠️ Agent system setup failed:', agentResult.error);
     }
+  }
 }
-async function setupMcpConfiguration(workingDir, dryRun1 = false) {
-    if (!dryRun1) {
-        console.log('🔌 Setting up MCP configuration...');
-        const mcpConfig = {
-            "mcpServers": {
-                "claude-flow-novice": {
-                    "command": "npx",
-                    "args": [
-                        "claude-flow-novice",
-                        "mcp",
-                        "start"
-                    ],
-                    "env": {
-                        "CLAUDE_FLOW_NOVICE_MODE": "novice",
-                        "CLAUDE_FLOW_NOVICE_SIMPLIFIED": "true"
-                    }
-                }
-            }
-        };
-        await fs.writeFile(`${workingDir}/.mcp.json`, JSON.stringify(mcpConfig, null, 2), 'utf8');
-        console.log('  ✅ Created .mcp.json configuration');
-    }
+
+async function setupMcpConfiguration(workingDir, dryRun = false) {
+  if (!dryRun) {
+    console.log('🔌 Setting up MCP configuration...');
+
+    const mcpConfig = {
+      "mcpServers": {
+        "claude-flow-novice": {
+          "command": "npx",
+          "args": ["claude-flow-novice", "mcp", "start"],
+          "env": {
+            "CLAUDE_FLOW_NOVICE_MODE": "novice",
+            "CLAUDE_FLOW_NOVICE_SIMPLIFIED": "true"
+          }
+        }
+      }
+    };
+
+    await fs.writeFile(
+      `${workingDir}/.mcp.json`,
+      JSON.stringify(mcpConfig, null, 2),
+      'utf8'
+    );
+    console.log('  ✅ Created .mcp.json configuration');
+  }
 }
-async function setupHooksSystem(workingDir, dryRun1 = false) {
-    if (!dryRun1) {
-        console.log('🪝 Setting up hooks system...');
-        // Create .claude/settings.json with hooks configuration
-        const settingsConfig = {
-            "hooks": {
-                "pre-tool": {
-                    "command": "npx claude-flow-novice hooks pre-task --description \"{{description}}\"",
-                    "enabled": true
-                },
-                "post-tool": {
-                    "command": "npx claude-flow-novice hooks post-task --task-id \"{{taskId}}\"",
-                    "enabled": true
-                },
-                "pre-edit": {
-                    "command": "npx claude-flow-novice hooks pre-edit --file \"{{file}}\"",
-                    "enabled": true
-                },
-                "post-edit": {
-                    "command": "npx claude-flow-novice hooks post-edit --file \"{{file}}\" --memory-key \"swarm/{{agent}}/{{step}}\"",
-                    "enabled": true
-                }
-            },
-            "coordination": {
-                "autoSpawn": true,
-                "memoryPersistence": true,
-                "swarmOrchestration": true
-            }
-        };
-        await fs.writeFile(`${workingDir}/.claude/settings.json`, JSON.stringify(settingsConfig, null, 2), 'utf8');
-        console.log('  ✅ Created hooks configuration');
-    }
+
+async function setupHooksSystem(workingDir, dryRun = false) {
+  if (!dryRun) {
+    console.log('🪝 Setting up hooks system...');
+
+    // Create .claude/settings.json with hooks configuration
+    const settingsConfig = {
+      "hooks": {
+        "pre-tool": {
+          "command": "npx claude-flow-novice hooks pre-task --description \"{{description}}\"",
+          "enabled": true
+        },
+        "post-tool": {
+          "command": "npx claude-flow-novice hooks post-task --task-id \"{{taskId}}\"",
+          "enabled": true
+        },
+        "pre-edit": {
+          "command": "npx claude-flow-novice hooks pre-edit --file \"{{file}}\"",
+          "enabled": true
+        },
+        "post-edit": {
+          "command": "npx claude-flow-novice hooks post-edit --file \"{{file}}\" --memory-key \"swarm/{{agent}}/{{step}}\"",
+          "enabled": true
+        }
+      },
+      "coordination": {
+        "autoSpawn": true,
+        "memoryPersistence": true,
+        "swarmOrchestration": true
+      }
+    };
+
+    await fs.writeFile(
+      `${workingDir}/.claude/settings.json`,
+      JSON.stringify(settingsConfig, null, 2),
+      'utf8'
+    );
+    console.log('  ✅ Created hooks configuration');
+  }
 }
-async function setupCoordinationSystem(workingDir, dryRun1 = false) {
-// Coordination system is already set up by createDirectoryStructure
-// This is a placeholder for future coordination setup logic
+
+async function setupCoordinationSystem(workingDir, dryRun = false) {
+  // Coordination system is already set up by createDirectoryStructure
+  // This is a placeholder for future coordination setup logic
 }
+
 /**
  * Setup monitoring and telemetry for token tracking
- */ async function setupMonitoring(workingDir) {
-    console.log('  📈 Configuring token usage tracking...');
-    const fs = await import("node:fs/promises");
-    const path = await import("path");
+ */
+async function setupMonitoring(workingDir) {
+  console.log('  📈 Configuring token usage tracking...');
+
+  const fs = await import('fs/promises');
+  const path = await import('path');
+
+  try {
+    // Create .claude-flow-novice directory for tracking data
+    const trackingDir = path.join(workingDir, '.claude-flow');
+    await fs.mkdir(trackingDir, { recursive: true });
+
+    // Create initial token usage file
+    const tokenUsageFile = path.join(trackingDir, 'token-usage.json');
+    const initialData = {
+      total: 0,
+      input: 0,
+      output: 0,
+      byAgent: {},
+      lastUpdated: new Date().toISOString(),
+    };
+
+    await fs.writeFile(tokenUsageFile, JSON.stringify(initialData, null, 2));
+    printSuccess('  ✓ Created token usage tracking file');
+
+    // Add telemetry configuration to .claude/settings.json if it exists
+    const settingsPath = path.join(workingDir, '.claude', 'settings.json');
     try {
-        // Create .claude-flow-novice directory for tracking data
-        const trackingDir = path.join(workingDir, '.claude-flow');
-        await fs.mkdir(trackingDir, {
-            recursive: true
-        });
-        // Create initial token usage file
-        const tokenUsageFile = path.join(trackingDir, 'token-usage.json');
-        const initialData = {
-            total: 0,
-            input: 0,
-            output: 0,
-            byAgent: {},
-            lastUpdated: new Date().toISOString()
-        };
-        await fs.writeFile(tokenUsageFile, JSON.stringify(initialData, null, 2));
-        printSuccess('  ✓ Created token usage tracking file');
-        // Add telemetry configuration to .claude/settings.json if it exists
-        const settingsPath = path.join(workingDir, '.claude', 'settings.json');
-        try {
-            const settingsContent = await fs.readFile(settingsPath, 'utf8');
-            const settings = JSON.parse(settingsContent);
-            // Add telemetry hook
-            if (!settings.hooks) settings.hooks = {};
-            if (!settings.hooks['post-task']) settings.hooks['post-task'] = [];
-            // Add token tracking hook
-            const tokenTrackingHook = 'npx claude-flow-novice internal track-tokens --session-id {{session_id}} --tokens {{token_usage}}';
-            if (!settings.hooks['post-task'].includes(tokenTrackingHook)) {
-                settings.hooks['post-task'].push(tokenTrackingHook);
-            }
-            await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-            printSuccess('  ✓ Added token tracking hooks to settings');
-        } catch (err) {
-            console.log('  ⚠️  Could not update settings.json:', err.message);
-        }
-        // Create monitoring configuration
-        const monitoringConfig = {
-            enabled: true,
-            telemetry: {
-                claudeCode: {
-                    env: 'CLAUDE_CODE_ENABLE_TELEMETRY',
-                    value: '1',
-                    description: 'Enable Claude Code OpenTelemetry metrics'
-                }
-            },
-            tracking: {
-                tokens: true,
-                costs: true,
-                agents: true,
-                sessions: true
-            },
-            storage: {
-                location: '.claude-flow/token-usage.json',
-                format: 'json',
-                rotation: 'monthly'
-            }
-        };
-        const configPath = path.join(trackingDir, 'monitoring.config.json');
-        await fs.writeFile(configPath, JSON.stringify(monitoringConfig, null, 2));
-        printSuccess('  ✓ Created monitoring configuration');
-        // Create shell profile snippet for environment variable
-        const envSnippet = `
+      const settingsContent = await fs.readFile(settingsPath, 'utf8');
+      const settings = JSON.parse(settingsContent);
+
+      // Add telemetry hook
+      if (!settings.hooks) settings.hooks = {};
+      if (!settings.hooks['post-task']) settings.hooks['post-task'] = [];
+
+      // Add token tracking hook
+      const tokenTrackingHook =
+        'npx claude-flow-novice internal track-tokens --session-id {{session_id}} --tokens {{token_usage}}';
+      if (!settings.hooks['post-task'].includes(tokenTrackingHook)) {
+        settings.hooks['post-task'].push(tokenTrackingHook);
+      }
+
+      await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+      printSuccess('  ✓ Added token tracking hooks to settings');
+    } catch (err) {
+      console.log('  ⚠️  Could not update settings.json:', err.message);
+    }
+
+    // Create monitoring configuration
+    const monitoringConfig = {
+      enabled: true,
+      telemetry: {
+        claudeCode: {
+          env: 'CLAUDE_CODE_ENABLE_TELEMETRY',
+          value: '1',
+          description: 'Enable Claude Code OpenTelemetry metrics',
+        },
+      },
+      tracking: {
+        tokens: true,
+        costs: true,
+        agents: true,
+        sessions: true,
+      },
+      storage: {
+        location: '.claude-flow/token-usage.json',
+        format: 'json',
+        rotation: 'monthly',
+      },
+    };
+
+    const configPath = path.join(trackingDir, 'monitoring.config.json');
+    await fs.writeFile(configPath, JSON.stringify(monitoringConfig, null, 2));
+    printSuccess('  ✓ Created monitoring configuration');
+
+    // Create shell profile snippet for environment variable
+    const envSnippet = `
 # Claude Flow Token Tracking
 # Add this to your shell profile (.bashrc, .zshrc, etc.)
 export CLAUDE_CODE_ENABLE_TELEMETRY=1
@@ -1086,544 +1273,606 @@ export CLAUDE_CODE_ENABLE_TELEMETRY=1
 # Optional: Set custom metrics path
 # export CLAUDE_METRICS_PATH="$HOME/.claude/metrics"
 `;
-        const envPath = path.join(trackingDir, 'env-setup.sh');
-        await fs.writeFile(envPath, envSnippet.trim());
-        printSuccess('  ✓ Created environment setup script');
-        console.log('\n  📋 To enable Claude Code telemetry:');
-        console.log('     1. Add to your shell profile: export CLAUDE_CODE_ENABLE_TELEMETRY=1');
-        console.log('     2. Or run: source .claude-flow/env-setup.sh');
-        console.log('\n  💡 Token usage will be tracked in .claude-flow/token-usage.json');
-        console.log('     Run: claude-flow-novice analysis token-usage --breakdown --cost-analysis');
-    } catch (err) {
-        printError(`  Failed to setup monitoring: ${err.message}`);
-    }
+
+    const envPath = path.join(trackingDir, 'env-setup.sh');
+    await fs.writeFile(envPath, envSnippet.trim());
+    printSuccess('  ✓ Created environment setup script');
+
+    console.log('\n  📋 To enable Claude Code telemetry:');
+    console.log('     1. Add to your shell profile: export CLAUDE_CODE_ENABLE_TELEMETRY=1');
+    console.log('     2. Or run: source .claude-flow/env-setup.sh');
+    console.log('\n  💡 Token usage will be tracked in .claude-flow/token-usage.json');
+    console.log('     Run: claude-flow-novice analysis token-usage --breakdown --cost-analysis');
+  } catch (err) {
+    printError(`  Failed to setup monitoring: ${err.message}`);
+  }
 }
+
 /**
  * Enhanced Claude Flow v2.0.0 initialization
- */ async function enhancedClaudeFlowInit(flags, subArgs = []) {
-    console.log('🚀 Initializing Claude Flow v2.0.0 with enhanced features...');
-    const workingDir = process.cwd();
-    const force = flags.force || flags.f;
-    const dryRun1 = flags.dryRun || flags['dry-run'] || flags.d;
-    const initSparc = flags.roo || subArgs && subArgs.includes('--roo'); // SPARC only with --roo flag
-    // Store parameters to avoid scope issues in async context
-    const args = subArgs || [];
-    const options = flags || {};
-    // Import fs module for Node.js
-    const fs = await import("node:fs/promises");
-    const { chmod } = fs;
-    try {
-        // Check existing files
-        const existingFiles = [];
-        const filesToCheck = [
-            'CLAUDE.md',
-            '.claude/settings.json',
-            '.mcp.json',
-            'claude-flow.config.json'
-        ];
-        for (const file of filesToCheck){
-            if (existsSync(`${workingDir}/${file}`)) {
-                existingFiles.push(file);
+ */
+async function enhancedClaudeFlowInit(flags, subArgs = []) {
+  console.log('🚀 Initializing Claude Flow v2.0.0 with enhanced features...');
+
+  const workingDir = process.cwd();
+  const force = flags.force || flags.f;
+  const dryRun = flags.dryRun || flags['dry-run'] || flags.d;
+  const initSparc = flags.roo || (subArgs && subArgs.includes('--roo')); // SPARC only with --roo flag
+
+  // Store parameters to avoid scope issues in async context
+  const args = subArgs || [];
+  const options = flags || {};
+
+  // Import fs module for Node.js
+  const fs = await import('fs/promises');
+  const { chmod } = fs;
+
+  try {
+    // Check existing files
+    const existingFiles = [];
+    const filesToCheck = [
+      'CLAUDE.md',
+      '.claude/settings.json',
+      '.mcp.json',
+      'claude-flow.config.json',
+    ];
+
+    for (const file of filesToCheck) {
+      if (existsSync(`${workingDir}/${file}`)) {
+        existingFiles.push(file);
+      }
+    }
+
+    if (existingFiles.length > 0 && !force) {
+      printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
+      console.log('Use --force to overwrite existing files');
+      return;
+    }
+
+    // Create CLAUDE.md from template
+    if (!dryRun) {
+      const claudeMdContent = await readClaudeMdTemplate();
+      await fs.writeFile(`${workingDir}/CLAUDE.md`, claudeMdContent, 'utf8');
+      printSuccess('✓ Created CLAUDE.md (Claude Flow v2.0.0 - Optimized Template)');
+    } else {
+      console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0 - Optimized Template)');
+    }
+
+    // Create .claude directory structure
+    const claudeDir = `${workingDir}/.claude`;
+    if (!dryRun) {
+      await fs.mkdir(claudeDir, { recursive: true });
+      await fs.mkdir(`${claudeDir}/commands`, { recursive: true });
+      await fs.mkdir(`${claudeDir}/helpers`, { recursive: true });
+      printSuccess('✓ Created .claude directory structure');
+    } else {
+      console.log('[DRY RUN] Would create .claude directory structure');
+    }
+
+    // Create settings.json
+    if (!dryRun) {
+      await fs.writeFile(`${claudeDir}/settings.json`, createEnhancedSettingsJson(), 'utf8');
+      printSuccess('✓ Created .claude/settings.json with hooks and MCP configuration');
+    } else {
+      console.log('[DRY RUN] Would create .claude/settings.json');
+    }
+
+    // Create settings.local.json with default MCP permissions
+    const settingsLocal = {
+      permissions: {
+        allow: ['mcp__ruv-swarm', 'mcp__claude-flow'],
+        deny: [],
+      },
+    };
+
+    if (!dryRun) {
+      await fs.writeFile(
+        `${claudeDir}/settings.local.json`,
+        JSON.stringify(settingsLocal, null, 2, 'utf8'),
+      );
+      printSuccess('✓ Created .claude/settings.local.json with default MCP permissions');
+    } else {
+      console.log(
+        '[DRY RUN] Would create .claude/settings.local.json with default MCP permissions',
+      );
+    }
+
+    // Setup bulletproof MCP configuration instead of legacy approach
+    console.log('\n🛡️  Setting up bulletproof MCP configuration...');
+
+    const mcpOptions = {
+      verbose: flags.verbose || false,
+      autoFix: flags['auto-fix'] !== false && !flags['no-auto-fix'], // Default true unless explicitly disabled
+      dryRun: dryRun,
+      enhancedUx: true, // Enable enhanced user experience
+      showEducation: flags['show-education'] || false,
+      serverConfig: {
+        mcpServers: {
+          'claude-flow-novice': {
+            command: 'npx',
+            args: ['claude-flow-novice', 'mcp', 'start'],
+            env: {
+              NODE_ENV: 'production',
+              CLAUDE_FLOW_NOVICE_MODE: 'novice'
             }
+          }
         }
-        if (existingFiles.length > 0 && !force) {
-            printWarning(`The following files already exist: ${existingFiles.join(', ')}`);
-            console.log('Use --force to overwrite existing files');
-            return;
-        }
-        // Create CLAUDE.md from template
-        if (!dryRun1) {
-            const claudeMdContent = await readClaudeMdTemplate();
-            await fs.writeFile(`${workingDir}/CLAUDE.md`, claudeMdContent, 'utf8');
-            printSuccess('✓ Created CLAUDE.md (Claude Flow v2.0.0 - Optimized Template)');
-        } else {
-            console.log('[DRY RUN] Would create CLAUDE.md (Claude Flow v2.0.0 - Optimized Template)');
-        }
-        // Create .claude directory structure
-        const claudeDir = `${workingDir}/.claude`;
-        if (!dryRun1) {
-            await fs.mkdir(claudeDir, {
-                recursive: true
-            });
-            await fs.mkdir(`${claudeDir}/commands`, {
-                recursive: true
-            });
-            await fs.mkdir(`${claudeDir}/helpers`, {
-                recursive: true
-            });
-            printSuccess('✓ Created .claude directory structure');
-        } else {
-            console.log('[DRY RUN] Would create .claude directory structure');
-        }
-        // Create settings.json
-        if (!dryRun1) {
-            await fs.writeFile(`${claudeDir}/settings.json`, createEnhancedSettingsJson(), 'utf8');
-            printSuccess('✓ Created .claude/settings.json with hooks and MCP configuration');
-        } else {
-            console.log('[DRY RUN] Would create .claude/settings.json');
-        }
-        // Create settings.local.json with default MCP permissions
-        const settingsLocal = {
-            permissions: {
-                allow: [
-                    'mcp__ruv-swarm',
-                    'mcp__claude-flow'
-                ],
-                deny: []
-            }
-        };
-        if (!dryRun1) {
-            await fs.writeFile(`${claudeDir}/settings.local.json`, JSON.stringify(settingsLocal, null, 2, 'utf8'));
-            printSuccess('✓ Created .claude/settings.local.json with default MCP permissions');
-        } else {
-            console.log('[DRY RUN] Would create .claude/settings.local.json with default MCP permissions');
+      }
+    };
+
+    let mcpSuccess = false;
+    try {
+      const { enhancedMcpInit } = await import('../../mcp/mcp-config-manager.js');
+      const result = await enhancedMcpInit(mcpOptions);
+
+      if (result.success) {
+        printSuccess('✓ Bulletproof MCP configuration completed successfully');
+        if (result.details) {
+          console.log(`   • Issues Fixed: ${result.details.issuesFixed || 0}`);
+          console.log(`   • Health Score: ${result.details.healthScore || 'N/A'}/100`);
         }
-        // Setup bulletproof MCP configuration instead of legacy approach
-        console.log('\n🛡️  Setting up bulletproof MCP configuration...');
-        const mcpOptions = {
-            verbose: flags.verbose || false,
-            autoFix: flags['auto-fix'] !== false && !flags['no-auto-fix'],
-            dryRun: dryRun1,
-            enhancedUx: true,
-            showEducation: flags['show-education'] || false,
-            serverConfig: {
-                mcpServers: {
-                    'claude-flow-novice': {
-                        command: 'npx',
-                        args: [
-                            'claude-flow-novice',
-                            'mcp',
-                            'start'
-                        ],
-                        env: {
-                            NODE_ENV: 'production',
-                            CLAUDE_FLOW_NOVICE_MODE: 'novice'
-                        }
-                    }
-                }
-            }
-        };
-        let mcpSuccess = false;
-        try {
-            const { enhancedMcpInit } = await import("../../mcp/mcp-config-manager.js");
-            const result = await enhancedMcpInit(mcpOptions);
-            if (result.success) {
-                printSuccess('✓ Bulletproof MCP configuration completed successfully');
-                if (result.details) {
-                    console.log(`   • Issues Fixed: ${result.details.issuesFixed || 0}`);
-                    console.log(`   • Health Score: ${result.details.healthScore || 'N/A'}/100`);
-                }
-                mcpSuccess = true;
-            } else {
-                printWarning(`⚠️  MCP configuration had issues: ${result.error || 'Unknown error'}`);
-                if (result.rollbackAvailable) {
-                    console.log('   🔄 Automatic rollback was performed');
-                }
-            }
-        } catch (error) {
-            printWarning(`⚠️  Bulletproof MCP setup failed: ${error.message}`);
-            printWarning('   📞 Falling back to legacy MCP configuration...');
-            // Fallback to legacy config creation
-            const mcpConfig = {
-                mcpServers: {
-                    'claude-flow-novice': {
-                        command: 'npx',
-                        args: [
-                            'claude-flow-novice',
-                            'mcp',
-                            'start'
-                        ],
-                        env: {
-                            NODE_ENV: 'production',
-                            CLAUDE_FLOW_NOVICE_MODE: 'novice'
-                        }
-                    }
-                }
-            };
-            if (!dryRun1) {
-                await fs.writeFile(`${workingDir}/.mcp.json`, JSON.stringify(mcpConfig, null, 2), 'utf8');
-                printSuccess('✓ Created .mcp.json with legacy configuration');
-            } else {
-                console.log('[DRY RUN] Would create .mcp.json with legacy configuration');
-            }
-            mcpSuccess = true; // Consider legacy success for continuation
+        mcpSuccess = true;
+      } else {
+        printWarning(`⚠️  MCP configuration had issues: ${result.error || 'Unknown error'}`);
+        if (result.rollbackAvailable) {
+          console.log('   🔄 Automatic rollback was performed');
         }
-        // Create claude-flow.config.json for Claude Flow specific settings
-        const claudeFlowConfig = {
-            features: {
-                autoTopologySelection: true,
-                parallelExecution: true,
-                neuralTraining: true,
-                bottleneckAnalysis: true,
-                smartAutoSpawning: true,
-                selfHealingWorkflows: true,
-                crossSessionMemory: true,
-                githubIntegration: true
-            },
-            performance: {
-                maxAgents: 10,
-                defaultTopology: 'hierarchical',
-                executionStrategy: 'parallel',
-                tokenOptimization: true,
-                cacheEnabled: true,
-                telemetryLevel: 'detailed'
+      }
+    } catch (error) {
+      printWarning(`⚠️  Bulletproof MCP setup failed: ${error.message}`);
+      printWarning('   📞 Falling back to legacy MCP configuration...');
+
+      // Fallback to legacy config creation
+      const mcpConfig = {
+        mcpServers: {
+          'claude-flow-novice': {
+            command: 'npx',
+            args: ['claude-flow-novice', 'mcp', 'start'],
+            env: {
+              NODE_ENV: 'production',
+              CLAUDE_FLOW_NOVICE_MODE: 'novice'
             }
-        };
-        if (!dryRun1) {
-            await fs.writeFile(`${workingDir}/claude-flow.config.json`, JSON.stringify(claudeFlowConfig, null, 2, 'utf8'));
-            printSuccess('✓ Created claude-flow.config.json for Claude Flow settings');
-        } else {
-            console.log('[DRY RUN] Would create claude-flow.config.json for Claude Flow settings');
+          }
         }
-        // Create command documentation
-        for (const [category, commands] of Object.entries(COMMAND_STRUCTURE)){
-            const categoryDir = `${claudeDir}/commands/${category}`;
-            if (!dryRun1) {
-                await fs.mkdir(categoryDir, {
-                    recursive: true
-                });
-                // Create category README
-                const categoryReadme = `# ${category.charAt(0).toUpperCase() + category.slice(1)} Commands
+      };
+
+      if (!dryRun) {
+        await fs.writeFile(`${workingDir}/.mcp.json`, JSON.stringify(mcpConfig, null, 2), 'utf8');
+        printSuccess('✓ Created .mcp.json with legacy configuration');
+      } else {
+        console.log('[DRY RUN] Would create .mcp.json with legacy configuration');
+      }
+      mcpSuccess = true; // Consider legacy success for continuation
+    }
+
+    // Create claude-flow.config.json for Claude Flow specific settings
+    const claudeFlowConfig = {
+      features: {
+        autoTopologySelection: true,
+        parallelExecution: true,
+        neuralTraining: true,
+        bottleneckAnalysis: true,
+        smartAutoSpawning: true,
+        selfHealingWorkflows: true,
+        crossSessionMemory: true,
+        githubIntegration: true,
+      },
+      performance: {
+        maxAgents: 10,
+        defaultTopology: 'hierarchical',
+        executionStrategy: 'parallel',
+        tokenOptimization: true,
+        cacheEnabled: true,
+        telemetryLevel: 'detailed',
+      },
+    };
+
+    if (!dryRun) {
+      await fs.writeFile(
+        `${workingDir}/claude-flow.config.json`,
+        JSON.stringify(claudeFlowConfig, null, 2, 'utf8'),
+      );
+      printSuccess('✓ Created claude-flow.config.json for Claude Flow settings');
+    } else {
+      console.log('[DRY RUN] Would create claude-flow.config.json for Claude Flow settings');
+    }
+
+    // Create command documentation
+    for (const [category, commands] of Object.entries(COMMAND_STRUCTURE)) {
+      const categoryDir = `${claudeDir}/commands/${category}`;
+
+      if (!dryRun) {
+        await fs.mkdir(categoryDir, { recursive: true });
+
+        // Create category README
+        const categoryReadme = `# ${category.charAt(0).toUpperCase() + category.slice(1)} Commands
 
 Commands for ${category} operations in Claude Flow.
 
 ## Available Commands
 
-${commands.map((cmd)=>`- [${cmd}](./${cmd}.md)`).join('\n')}
+${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
 `;
-                await fs.writeFile(`${categoryDir}/README.md`, categoryReadme, 'utf8');
-                // Create individual command docs
-                for (const command of commands){
-                    const doc = createCommandDoc(category, command);
-                    if (doc) {
-                        await fs.writeFile(`${categoryDir}/${command}.md`, doc, 'utf8');
-                    }
-                }
-                console.log(`  ✓ Created ${commands.length} ${category} command docs`);
-            } else {
-                console.log(`[DRY RUN] Would create ${commands.length} ${category} command docs`);
-            }
-        }
-        // Create wrapper scripts
-        if (!dryRun1) {
-            // Unix wrapper - now uses universal ES module compatible wrapper
-            const unixWrapper = createWrapperScript('unix');
-            await fs.writeFile(`${workingDir}/claude-flow`, unixWrapper, 'utf8');
-            await fs.chmod(`${workingDir}/claude-flow`, 0o755);
-            // Windows wrapper
-            await fs.writeFile(`${workingDir}/claude-flow.bat`, createWrapperScript('windows', 'utf8'));
-            // PowerShell wrapper
-            await fs.writeFile(`${workingDir}/claude-flow.ps1`, createWrapperScript('powershell', 'utf8'));
-            printSuccess('✓ Created platform-specific wrapper scripts');
-        } else {
-            console.log('[DRY RUN] Would create wrapper scripts');
+        await fs.writeFile(`${categoryDir}/README.md`, categoryReadme, 'utf8');
+
+        // Create individual command docs
+        for (const command of commands) {
+          const doc = createCommandDoc(category, command);
+          if (doc) {
+            await fs.writeFile(`${categoryDir}/${command}.md`, doc, 'utf8');
+          }
         }
-        // Create helper scripts
-        const helpers = [
-            'setup-mcp.sh',
-            'quick-start.sh',
-            'github-setup.sh',
-            'github-safe.js',
-            'standard-checkpoint-hooks.sh',
-            'checkpoint-manager.sh'
-        ];
-        for (const helper of helpers){
-            if (!dryRun1) {
-                const content = createHelperScript(helper);
-                if (content) {
-                    await fs.writeFile(`${claudeDir}/helpers/${helper}`, content, 'utf8');
-                    await fs.chmod(`${claudeDir}/helpers/${helper}`, 0o755);
-                }
-            }
+
+        console.log(`  ✓ Created ${commands.length} ${category} command docs`);
+      } else {
+        console.log(`[DRY RUN] Would create ${commands.length} ${category} command docs`);
+      }
+    }
+
+    // Create wrapper scripts
+    if (!dryRun) {
+      // Unix wrapper - now uses universal ES module compatible wrapper
+      const unixWrapper = createWrapperScript('unix');
+      await fs.writeFile(`${workingDir}/claude-flow`, unixWrapper, 'utf8');
+      await fs.chmod(`${workingDir}/claude-flow`, 0o755);
+
+      // Windows wrapper
+      await fs.writeFile(`${workingDir}/claude-flow.bat`, createWrapperScript('windows', 'utf8'));
+
+      // PowerShell wrapper
+      await fs.writeFile(
+        `${workingDir}/claude-flow.ps1`,
+        createWrapperScript('powershell', 'utf8'),
+      );
+
+      printSuccess('✓ Created platform-specific wrapper scripts');
+    } else {
+      console.log('[DRY RUN] Would create wrapper scripts');
+    }
+
+    // Create helper scripts
+    const helpers = [
+      'setup-mcp.sh',
+      'quick-start.sh',
+      'github-setup.sh',
+      'github-safe.js',
+      'standard-checkpoint-hooks.sh',
+      'checkpoint-manager.sh',
+    ];
+    for (const helper of helpers) {
+      if (!dryRun) {
+        const content = createHelperScript(helper);
+        if (content) {
+          await fs.writeFile(`${claudeDir}/helpers/${helper}`, content, 'utf8');
+          await fs.chmod(`${claudeDir}/helpers/${helper}`, 0o755);
         }
-        if (!dryRun1) {
-            printSuccess(`✓ Created ${helpers.length} helper scripts`);
+      }
+    }
+
+    if (!dryRun) {
+      printSuccess(`✓ Created ${helpers.length} helper scripts`);
+    } else {
+      console.log(`[DRY RUN] Would create ${helpers.length} helper scripts`);
+    }
+
+    // Create standard directories from original init
+    const standardDirs = [
+      'memory',
+      'memory/agents',
+      'memory/sessions',
+      'coordination',
+      'coordination/memory_bank',
+      'coordination/subtasks',
+      'coordination/orchestration',
+      '.swarm', // Add .swarm directory for shared memory
+      '.hive-mind', // Add .hive-mind directory for hive-mind system
+      '.claude/checkpoints', // Add checkpoints directory for Git checkpoint system
+    ];
+
+    for (const dir of standardDirs) {
+      if (!dryRun) {
+        await fs.mkdir(`${workingDir}/${dir}`, { recursive: true });
+      }
+    }
+
+    if (!dryRun) {
+      printSuccess('✓ Created standard directory structure');
+
+      // Initialize memory system
+      const initialData = { agents: [], tasks: [], lastUpdated: Date.now() };
+      await fs.writeFile(
+        `${workingDir}/memory/claude-flow-data.json`,
+        JSON.stringify(initialData, null, 2, 'utf8'),
+      );
+
+      // Create README files
+      await fs.writeFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme(), 'utf8');
+      await fs.writeFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme(), 'utf8');
+
+      printSuccess('✓ Initialized memory system');
+
+      // Initialize memory database with fallback support
+      try {
+        // Import and initialize FallbackMemoryStore to create the database
+        const { FallbackMemoryStore } = await import('../../../memory/fallback-store.js');
+        const memoryStore = new FallbackMemoryStore();
+        await memoryStore.initialize();
+
+        if (memoryStore.isUsingFallback()) {
+          printSuccess('✓ Initialized memory system (in-memory fallback for npx compatibility)');
+          console.log(
+            '  💡 For persistent storage, install locally: npm install claude-flow@alpha',
+          );
         } else {
-            console.log(`[DRY RUN] Would create ${helpers.length} helper scripts`);
-        }
-        // Create standard directories from original init
-        const standardDirs = [
-            'memory',
-            'memory/agents',
-            'memory/sessions',
-            'coordination',
-            'coordination/memory_bank',
-            'coordination/subtasks',
-            'coordination/orchestration',
-            '.swarm',
-            '.hive-mind',
-            '.claude/checkpoints'
-        ];
-        for (const dir of standardDirs){
-            if (!dryRun1) {
-                await fs.mkdir(`${workingDir}/${dir}`, {
-                    recursive: true
-                });
-            }
-        }
-        if (!dryRun1) {
-            printSuccess('✓ Created standard directory structure');
-            // Initialize memory system
-            const initialData = {
-                agents: [],
-                tasks: [],
-                lastUpdated: Date.now()
-            };
-            await fs.writeFile(`${workingDir}/memory/claude-flow-data.json`, JSON.stringify(initialData, null, 2, 'utf8'));
-            // Create README files
-            await fs.writeFile(`${workingDir}/memory/agents/README.md`, createAgentsReadme(), 'utf8');
-            await fs.writeFile(`${workingDir}/memory/sessions/README.md`, createSessionsReadme(), 'utf8');
-            printSuccess('✓ Initialized memory system');
-            // Initialize memory database with fallback support
-            try {
-                // Import and initialize FallbackMemoryStore to create the database
-                const { FallbackMemoryStore } = await import("../../../memory/fallback-store.js");
-                const memoryStore = new FallbackMemoryStore();
-                await memoryStore.initialize();
-                if (memoryStore.isUsingFallback()) {
-                    printSuccess('✓ Initialized memory system (in-memory fallback for npx compatibility)');
-                    console.log('  💡 For persistent storage, install locally: npm install claude-flow@alpha');
-                } else {
-                    printSuccess('✓ Initialized memory database (.swarm/memory.db)');
-                }
-                memoryStore.close();
-            } catch (err) {
-                console.log(`  ⚠️  Could not initialize memory system: ${err.message}`);
-                console.log('     Memory will be initialized on first use');
-            }
-            // Initialize comprehensive hive-mind system
-            console.log('\n🧠 Initializing Hive Mind System...');
-            try {
-                const hiveMindOptions = {
-                    config: {
-                        integration: {
-                            claudeCode: {
-                                enabled: isClaudeCodeInstalled()
-                            },
-                            mcpTools: {
-                                enabled: true
-                            }
-                        },
-                        monitoring: {
-                            enabled: flags.monitoring || false
-                        }
-                    }
-                };
-                const hiveMindResult = await initializeHiveMind(workingDir, hiveMindOptions, dryRun1);
-                if (hiveMindResult.success) {
-                    printSuccess(`✓ Hive Mind System initialized with ${hiveMindResult.features.length} features`);
-                    // Log individual features
-                    hiveMindResult.features.forEach((feature)=>{
-                        console.log(`    • ${feature}`);
-                    });
-                } else {
-                    console.log(`  ⚠️  Hive Mind initialization failed: ${hiveMindResult.error}`);
-                    if (hiveMindResult.rollbackRequired) {
-                        console.log('  🔄 Automatic rollback may be required');
-                    }
-                }
-            } catch (err) {
-                console.log(`  ⚠️  Could not initialize hive-mind system: ${err.message}`);
-            }
+          printSuccess('✓ Initialized memory database (.swarm/memory.db)');
         }
-        // Update .gitignore with Claude Flow entries
-        const gitignoreResult = await updateGitignore(workingDir, force, dryRun1);
-        if (gitignoreResult.success) {
-            if (!dryRun1) {
-                printSuccess(`✓ ${gitignoreResult.message}`);
-            } else {
-                console.log(gitignoreResult.message);
-            }
+
+        memoryStore.close();
+      } catch (err) {
+        console.log(`  ⚠️  Could not initialize memory system: ${err.message}`);
+        console.log('     Memory will be initialized on first use');
+      }
+
+      // Initialize comprehensive hive-mind system
+      console.log('\n🧠 Initializing Hive Mind System...');
+      try {
+        const hiveMindOptions = {
+          config: {
+            integration: {
+              claudeCode: { enabled: isClaudeCodeInstalled() },
+              mcpTools: { enabled: true },
+            },
+            monitoring: { enabled: flags.monitoring || false },
+          },
+        };
+
+        const hiveMindResult = await initializeHiveMind(workingDir, hiveMindOptions, dryRun);
+
+        if (hiveMindResult.success) {
+          printSuccess(
+            `✓ Hive Mind System initialized with ${hiveMindResult.features.length} features`,
+          );
+
+          // Log individual features
+          hiveMindResult.features.forEach((feature) => {
+            console.log(`    • ${feature}`);
+          });
         } else {
-            console.log(`  ⚠️  ${gitignoreResult.message}`);
-        }
-        // SPARC initialization (only with --roo flag)
-        let sparcInitialized = false;
-        if (initSparc) {
-            console.log('\n🚀 Initializing SPARC development environment...');
-            try {
-                // Run create-sparc
-                console.log('  🔄 Running: npx -y create-sparc init --force');
-                execSync('npx -y create-sparc init --force', {
-                    cwd: workingDir,
-                    stdio: 'inherit'
-                });
-                sparcInitialized = true;
-                printSuccess('✅ SPARC environment initialized successfully');
-            } catch (err) {
-                console.log(`  ⚠️  Could not run create-sparc: ${err.message}`);
-                console.log('     SPARC features will be limited to basic functionality');
-            }
+          console.log(`  ⚠️  Hive Mind initialization failed: ${hiveMindResult.error}`);
+          if (hiveMindResult.rollbackRequired) {
+            console.log('  🔄 Automatic rollback may be required');
+          }
         }
-        // Create Claude slash commands for SPARC
-        if (sparcInitialized && !dryRun1) {
-            console.log('\n📝 Creating Claude Code slash commands...');
-            await createClaudeSlashCommands(workingDir);
-        }
-        // Check for Claude Code and set up MCP servers (always enabled by default)
-        if (!dryRun1 && isClaudeCodeInstalled()) {
-            console.log('\n🔍 Claude Code CLI detected!');
-            const skipMcp = options && options['skip-mcp'] || subArgs && subArgs.includes && subArgs.includes('--skip-mcp');
-            if (!skipMcp) {
-                // Use bulletproof MCP setup for enhanced init
-                const mcpSuccess = await setupBulletproofMcp({
-                    verbose: true,
-                    autoFix: true,
-                    dryRun: dryRun1
-                });
-                if (!mcpSuccess) {
-                    console.log('  💡 If you encounter issues, run: claude mcp remove claude-flow-novice -s local');
-                }
-            } else {
-                console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
-                console.log('\n  📋 To add MCP servers manually:');
-                console.log('     claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
-                console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
-                // Flow-nexus integration removed
-                console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
-            }
-        } else if (!dryRun1 && !isClaudeCodeInstalled()) {
-            console.log('\n⚠️  Claude Code CLI not detected!');
-            console.log('\n  📥 To install Claude Code:');
-            console.log('     npm install -g @anthropic-ai/claude-code');
-            console.log('\n  📋 After installing, add MCP servers:');
-            console.log('     claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
-            console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
-            // Flow-nexus integration removed
-            console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
+      } catch (err) {
+        console.log(`  ⚠️  Could not initialize hive-mind system: ${err.message}`);
+      }
+    }
+
+    // Update .gitignore with Claude Flow entries
+    const gitignoreResult = await updateGitignore(workingDir, force, dryRun);
+    if (gitignoreResult.success) {
+      if (!dryRun) {
+        printSuccess(`✓ ${gitignoreResult.message}`);
+      } else {
+        console.log(gitignoreResult.message);
+      }
+    } else {
+      console.log(`  ⚠️  ${gitignoreResult.message}`);
+    }
+
+    // SPARC initialization (only with --roo flag)
+    let sparcInitialized = false;
+    if (initSparc) {
+      console.log('\n🚀 Initializing SPARC development environment...');
+      try {
+        // Run create-sparc
+        console.log('  🔄 Running: npx -y create-sparc init --force');
+        execSync('npx -y create-sparc init --force', {
+          cwd: workingDir,
+          stdio: 'inherit',
+        });
+        sparcInitialized = true;
+        printSuccess('✅ SPARC environment initialized successfully');
+      } catch (err) {
+        console.log(`  ⚠️  Could not run create-sparc: ${err.message}`);
+        console.log('     SPARC features will be limited to basic functionality');
+      }
+    }
+
+    // Create Claude slash commands for SPARC
+    if (sparcInitialized && !dryRun) {
+      console.log('\n📝 Creating Claude Code slash commands...');
+      await createClaudeSlashCommands(workingDir);
+    }
+
+    // Check for Claude Code and set up MCP servers (always enabled by default)
+    if (!dryRun && isClaudeCodeInstalled()) {
+      console.log('\n🔍 Claude Code CLI detected!');
+      const skipMcp =
+        (options && options['skip-mcp']) ||
+        (subArgs && subArgs.includes && subArgs.includes('--skip-mcp'));
+
+      if (!skipMcp) {
+        // Use bulletproof MCP setup for enhanced init
+        const mcpSuccess = await setupBulletproofMcp({
+          verbose: true,
+          autoFix: true,
+          dryRun: dryRun
+        });
+
+        if (!mcpSuccess) {
+          console.log('  💡 If you encounter issues, run: claude mcp remove claude-flow-novice -s local');
         }
-        // Create agent directories and copy all agent files
-        console.log('\n🤖 Setting up agent system...');
-        if (!dryRun1) {
-            await createAgentDirectories(workingDir, dryRun1);
-            const agentResult = await copyAgentFiles(workingDir, {
-                force: force,
-                dryRun: dryRun1
-            });
-            if (agentResult.success) {
-                await validateAgentSystem(workingDir);
-                // Copy command files including Flow Nexus commands
-                console.log('\n📚 Setting up command system...');
-                const commandResult = await copyCommandFiles(workingDir, {
-                    force: force,
-                    dryRun: dryRun1
-                });
-                if (commandResult.success) {
-                    console.log('✅ ✓ Command system setup complete with Flow Nexus integration');
-                } else {
-                    console.log('⚠️  Command system setup failed:', commandResult.error);
-                }
-                console.log('✅ ✓ Agent system setup complete with 64 specialized agents');
-            } else {
-                console.log('⚠️  Agent system setup failed:', agentResult.error);
-            }
-            // Setup hooks system for novice users
-            console.log('\n🪝 Setting up hooks system...');
-            const hooksConfig = {
-                hooks: {
-                    pre_task: {
-                        enabled: true,
-                        command: "npx claude-flow-novice hooks pre-task --description \"$TASK_DESCRIPTION\"",
-                        description: "Pre-task coordination hook"
-                    },
-                    post_edit: {
-                        enabled: true,
-                        command: "npx claude-flow-novice hooks post-edit --file \"$FILE_PATH\" --memory-key \"swarm/$AGENT_ID/$STEP\"",
-                        description: "Post-edit memory storage hook"
-                    },
-                    post_task: {
-                        enabled: true,
-                        command: "npx claude-flow-novice hooks post-task --task-id \"$TASK_ID\"",
-                        description: "Post-task completion hook"
-                    }
-                },
-                memory: {
-                    enabled: true,
-                    persistence: "local",
-                    namespace: "claude-flow-novice"
-                }
-            };
-            const hooksConfigPath = `${claudeDir}/hooks.json`;
-            await fs.writeFile(hooksConfigPath, JSON.stringify(hooksConfig, null, 2), 'utf8');
-            console.log('✅ ✓ Hooks system setup complete with automated coordination');
+      } else {
+        console.log('  ℹ️  Skipping MCP setup (--skip-mcp flag used)');
+        console.log('\n  📋 To add MCP servers manually:');
+        console.log('     claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
+        console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+        // Flow-nexus integration removed
+        console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
+      }
+    } else if (!dryRun && !isClaudeCodeInstalled()) {
+      console.log('\n⚠️  Claude Code CLI not detected!');
+      console.log('\n  📥 To install Claude Code:');
+      console.log('     npm install -g @anthropic-ai/claude-code');
+      console.log('\n  📋 After installing, add MCP servers:');
+      console.log('     claude mcp add claude-flow-novice npx claude-flow-novice mcp start');
+      console.log('     claude mcp add ruv-swarm npx ruv-swarm@latest mcp start');
+      // Flow-nexus integration removed
+      console.log('\n  💡 MCP servers are defined in .mcp.json (project scope)');
+    }
+
+    // Create agent directories and copy all agent files
+    console.log('\n🤖 Setting up agent system...');
+    if (!dryRun) {
+      await createAgentDirectories(workingDir, dryRun);
+      const agentResult = await copyAgentFiles(workingDir, {
+        force: force,
+        dryRun: dryRun,
+      });
+
+      if (agentResult.success) {
+        await validateAgentSystem(workingDir);
+
+        // Copy command files including Flow Nexus commands
+        console.log('\n📚 Setting up command system...');
+        const commandResult = await copyCommandFiles(workingDir, {
+          force: force,
+          dryRun: dryRun,
+        });
+
+        if (commandResult.success) {
+          console.log('✅ ✓ Command system setup complete with Flow Nexus integration');
         } else {
-            console.log('  [DRY RUN] Would create agent system with 64 specialized agents');
-            console.log('  [DRY RUN] Would create hooks system with automated coordination');
+          console.log('⚠️  Command system setup failed:', commandResult.error);
         }
-        // Optional: Setup monitoring and telemetry
-        const enableMonitoring = flags.monitoring || flags['enable-monitoring'];
-        if (enableMonitoring && !dryRun1) {
-            console.log('\n📊 Setting up monitoring and telemetry...');
-            await setupMonitoring(workingDir);
-        }
-        // Final instructions with hive-mind status
-        console.log('\n🎉 Claude Flow v2.0.0 initialization complete!');
-        // Display MCP setup status prominently
-        if (mcpSuccess) {
-            console.log('\n🛡️  Bulletproof MCP Configuration Status:');
-            console.log('  ✅ MCP server successfully configured with auto-recovery');
-            console.log('  ✅ Conflict detection and resolution enabled');
-            console.log('  ✅ Automatic backup and rollback capability active');
-            console.log('  ✅ Project-specific configuration created (.mcp.json)');
-        } else {
-            console.log('\n⚠️  MCP Configuration Status:');
-            console.log('  ⚠️  MCP setup completed with fallback configuration');
-            console.log('  💡 Run health check: npx claude-flow-novice mcp health');
+
+        console.log('✅ ✓ Agent system setup complete with 64 specialized agents');
+      } else {
+        console.log('⚠️  Agent system setup failed:', agentResult.error);
+      }
+
+      // Setup hooks system for novice users
+      console.log('\n🪝 Setting up hooks system...');
+      const hooksConfig = {
+        hooks: {
+          pre_task: {
+            enabled: true,
+            command: "npx claude-flow-novice hooks pre-task --description \"$TASK_DESCRIPTION\"",
+            description: "Pre-task coordination hook"
+          },
+          post_edit: {
+            enabled: true,
+            command: "npx claude-flow-novice hooks post-edit --file \"$FILE_PATH\" --memory-key \"swarm/$AGENT_ID/$STEP\"",
+            description: "Post-edit memory storage hook"
+          },
+          post_task: {
+            enabled: true,
+            command: "npx claude-flow-novice hooks post-task --task-id \"$TASK_ID\"",
+            description: "Post-task completion hook"
+          }
+        },
+        memory: {
+          enabled: true,
+          persistence: "local",
+          namespace: "claude-flow-novice"
         }
-        // Display hive-mind status
-        const hiveMindStatus = getHiveMindStatus(workingDir);
-        console.log('\n🧠 Hive Mind System Status:');
-        console.log(`  Configuration: ${hiveMindStatus.configured ? '✅ Ready' : '❌ Missing'}`);
-        console.log(`  Database: ${hiveMindStatus.database === 'sqlite' ? '✅ SQLite' : hiveMindStatus.database === 'fallback' ? '⚠️ JSON Fallback' : '❌ Not initialized'}`);
-        console.log(`  Directory Structure: ${hiveMindStatus.directories ? '✅ Created' : '❌ Missing'}`);
-        console.log('\n📚 Quick Start:');
-        if (isClaudeCodeInstalled()) {
-            console.log('1. Verify MCP setup: claude mcp list');
-            console.log('2. View available commands: ls .claude/commands/');
-            console.log('3. Start a swarm: npx claude-flow-novice swarm "your objective" --claude');
-            console.log('4. Use hive-mind: npx claude-flow-novice hive-mind spawn "command" --claude');
-            console.log('5. Use enhanced MCP tools in Claude Code for bulletproof coordination');
-            if (hiveMindStatus.configured) {
-                console.log('5. Initialize first swarm: npx claude-flow-novice hive-mind init');
-            }
+      };
+
+      const hooksConfigPath = `${claudeDir}/hooks.json`;
+      await fs.writeFile(hooksConfigPath, JSON.stringify(hooksConfig, null, 2), 'utf8');
+      console.log('✅ ✓ Hooks system setup complete with automated coordination');
+
+    } else {
+      console.log('  [DRY RUN] Would create agent system with 64 specialized agents');
+      console.log('  [DRY RUN] Would create hooks system with automated coordination');
+    }
+
+    // Optional: Setup monitoring and telemetry
+    const enableMonitoring = flags.monitoring || flags['enable-monitoring'];
+    if (enableMonitoring && !dryRun) {
+      console.log('\n📊 Setting up monitoring and telemetry...');
+      await setupMonitoring(workingDir);
+    }
+
+    // Final instructions with hive-mind status
+    console.log('\n🎉 Claude Flow v2.0.0 initialization complete!');
+
+    // Display MCP setup status prominently
+    if (mcpSuccess) {
+      console.log('\n🛡️  Bulletproof MCP Configuration Status:');
+      console.log('  ✅ MCP server successfully configured with auto-recovery');
+      console.log('  ✅ Conflict detection and resolution enabled');
+      console.log('  ✅ Automatic backup and rollback capability active');
+      console.log('  ✅ Project-specific configuration created (.mcp.json)');
+    } else {
+      console.log('\n⚠️  MCP Configuration Status:');
+      console.log('  ⚠️  MCP setup completed with fallback configuration');
+      console.log('  💡 Run health check: npx claude-flow-novice mcp health');
+    }
+
+    // Display hive-mind status
+    const hiveMindStatus = getHiveMindStatus(workingDir);
+    console.log('\n🧠 Hive Mind System Status:');
+    console.log(`  Configuration: ${hiveMindStatus.configured ? '✅ Ready' : '❌ Missing'}`);
+    console.log(
+      `  Database: ${hiveMindStatus.database === 'sqlite' ? '✅ SQLite' : hiveMindStatus.database === 'fallback' ? '⚠️ JSON Fallback' : '❌ Not initialized'}`,
+    );
+    console.log(
+      `  Directory Structure: ${hiveMindStatus.directories ? '✅ Created' : '❌ Missing'}`,
+    );
+
+    console.log('\n📚 Quick Start:');
+    if (isClaudeCodeInstalled()) {
+      console.log('1. Verify MCP setup: claude mcp list');
+      console.log('2. View available commands: ls .claude/commands/');
+      console.log('3. Start a swarm: npx claude-flow-novice swarm "your objective" --claude');
+      console.log('4. Use hive-mind: npx claude-flow-novice hive-mind spawn "command" --claude');
+      console.log('5. Use enhanced MCP tools in Claude Code for bulletproof coordination');
+      if (hiveMindStatus.configured) {
+        console.log('5. Initialize first swarm: npx claude-flow-novice hive-mind init');
+      }
+    } else {
+      console.log('1. Install Claude Code: npm install -g @anthropic-ai/claude-code');
+      console.log('2. Add MCP servers (see instructions above)');
+      console.log('3. View available commands: ls .claude/commands/');
+      console.log('4. Start a swarm: npx claude-flow-novice swarm "your objective" --claude');
+      console.log('5. Use hive-mind: npx claude-flow-novice hive-mind spawn "command" --claude');
+      if (hiveMindStatus.configured) {
+        console.log('6. Initialize first swarm: npx claude-flow-novice hive-mind init');
+      }
+    }
+    console.log('\n💡 Tips:');
+    console.log('• Check .claude/commands/ for detailed documentation');
+    console.log('• Use --help with any command for options');
+    console.log('• Run commands with --claude flag for best Claude Code integration');
+    if (mcpSuccess) {
+      console.log('• MCP health check: npx claude-flow-novice mcp health');
+      console.log('• Configuration backups are automatically created for safety');
+      console.log('• Project-specific .mcp.json prevents conflicts with other projects');
+    }
+    console.log('• Enable GitHub integration with .claude/helpers/github-setup.sh');
+    console.log('• Git checkpoints are automatically enabled in settings.json');
+    console.log('• Use .claude/helpers/checkpoint-manager.sh for easy rollback');
+  } catch (err) {
+    printError(`Failed to initialize Claude Flow v2.0.0: ${err.message}`);
+
+    // Attempt hive-mind rollback if it was partially initialized
+    try {
+      const hiveMindStatus = getHiveMindStatus(workingDir);
+      if (hiveMindStatus.directories || hiveMindStatus.configured) {
+        console.log('\n🔄 Attempting hive-mind system rollback...');
+        const rollbackResult = await rollbackHiveMindInit(workingDir);
+        if (rollbackResult.success) {
+          console.log('  ✅ Hive-mind rollback completed');
         } else {
-            console.log('1. Install Claude Code: npm install -g @anthropic-ai/claude-code');
-            console.log('2. Add MCP servers (see instructions above)');
-            console.log('3. View available commands: ls .claude/commands/');
-            console.log('4. Start a swarm: npx claude-flow-novice swarm "your objective" --claude');
-            console.log('5. Use hive-mind: npx claude-flow-novice hive-mind spawn "command" --claude');
-            if (hiveMindStatus.configured) {
-                console.log('6. Initialize first swarm: npx claude-flow-novice hive-mind init');
-            }
-        }
-        console.log('\n💡 Tips:');
-        console.log('• Check .claude/commands/ for detailed documentation');
-        console.log('• Use --help with any command for options');
-        console.log('• Run commands with --claude flag for best Claude Code integration');
-        if (mcpSuccess) {
-            console.log('• MCP health check: npx claude-flow-novice mcp health');
-            console.log('• Configuration backups are automatically created for safety');
-            console.log('• Project-specific .mcp.json prevents conflicts with other projects');
-        }
-        console.log('• Enable GitHub integration with .claude/helpers/github-setup.sh');
-        console.log('• Git checkpoints are automatically enabled in settings.json');
-        console.log('• Use .claude/helpers/checkpoint-manager.sh for easy rollback');
-    } catch (err) {
-        printError(`Failed to initialize Claude Flow v2.0.0: ${err.message}`);
-        // Attempt hive-mind rollback if it was partially initialized
-        try {
-            const hiveMindStatus = getHiveMindStatus(workingDir);
-            if (hiveMindStatus.directories || hiveMindStatus.configured) {
-                console.log('\n🔄 Attempting hive-mind system rollback...');
-                const rollbackResult = await rollbackHiveMindInit(workingDir);
-                if (rollbackResult.success) {
-                    console.log('  ✅ Hive-mind rollback completed');
-                } else {
-                    console.log(`  ⚠️  Hive-mind rollback failed: ${rollbackResult.error}`);
-                }
-            }
-        } catch (rollbackErr) {
-            console.log(`  ⚠️  Rollback error: ${rollbackErr.message}`);
+          console.log(`  ⚠️  Hive-mind rollback failed: ${rollbackResult.error}`);
         }
+      }
+    } catch (rollbackErr) {
+      console.log(`  ⚠️  Rollback error: ${rollbackErr.message}`);
     }
-} // Flow Nexus initialization removed
+  }
+}
+
+// Flow Nexus initialization removed