claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/cli/simple-commands/swarm.js

@@ -1,121 +1,150 @@
 /**
  * Swarm command wrapper for simple CLI
- */ import { mkdirAsync, writeTextFile, exit } from "../node-compat.js";
-import { spawn } from "child_process";
-import { existsSync, chmodSync, statSync } from "fs";
-import { open } from "node:fs/promises";
-import process from "process";
+ */
+
+import { args, mkdirAsync, writeTextFile, exit, cwd } from '../node-compat.js';
+import { spawn, execSync } from 'child_process';
+import { existsSync, chmodSync, statSync } from 'fs';
+import { open } from 'fs/promises';
+import process from 'process';
+import path from 'path';
+
 /**
  * Detects if the environment is headless (non-interactive)
- */ function isHeadlessEnvironment() {
-    // Check for common CI environment variables
-    const ciEnvironments = [
-        'CI',
-        'GITHUB_ACTIONS',
-        'GITLAB_CI',
-        'JENKINS_URL',
-        'CIRCLECI',
-        'TRAVIS',
-        'BUILDKITE',
-        'DRONE',
-        'DOCKER_CONTAINER'
-    ];
-    const isCI = ciEnvironments.some((env)=>process.env[env]);
-    // Check if running in Docker
-    const isDocker = existsSync('/.dockerenv') || existsSync('/proc/1/cgroup') && require('fs').readFileSync('/proc/1/cgroup', 'utf8').includes('docker');
-    // Check TTY availability
-    const hasTTY = process.stdin.isTTY && process.stdout.isTTY;
-    return isCI || isDocker || !hasTTY;
+ */
+function isHeadlessEnvironment() {
+  // Check for common CI environment variables
+  const ciEnvironments = [
+    'CI',
+    'GITHUB_ACTIONS',
+    'GITLAB_CI',
+    'JENKINS_URL',
+    'CIRCLECI',
+    'TRAVIS',
+    'BUILDKITE',
+    'DRONE',
+    'DOCKER_CONTAINER',
+  ];
+
+  const isCI = ciEnvironments.some((env) => process.env[env]);
+
+  // Check if running in Docker
+  const isDocker =
+    existsSync('/.dockerenv') ||
+    (existsSync('/proc/1/cgroup') &&
+      require('fs').readFileSync('/proc/1/cgroup', 'utf8').includes('docker'));
+
+  // Check TTY availability
+  const hasTTY = process.stdin.isTTY && process.stdout.isTTY;
+
+  return isCI || isDocker || !hasTTY;
 }
+
 /**
  * Basic swarm implementation for fallback scenarios
- */ async function basicSwarmNew(args, flags) {
-    const objective = (args || []).join(' ').trim();
-    if (!objective) {
-        console.error('❌ Usage: swarm <objective>');
-        showSwarmHelp();
-        return;
-    }
-    const isHeadless = isHeadlessEnvironment();
-    // Configure for headless mode
+ */
+async function basicSwarmNew(args, flags) {
+  const objective = (args || []).join(' ').trim();
+
+  if (!objective) {
+    console.error('❌ Usage: swarm <objective>');
+    showSwarmHelp();
+    return;
+  }
+
+  const isHeadless = isHeadlessEnvironment();
+
+  // Configure for headless mode
+  if (isHeadless) {
+    console.log('🤖 Headless environment detected - running in non-interactive mode');
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'stream-json', // Use stream-json for Claude compatibility
+      'no-auto-permissions': false,
+    };
+  }
+
+  // Set up graceful shutdown handlers
+  const cleanup = () => {
+    console.log('\n🛑 Shutting down swarm gracefully...');
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+
+  try {
+    // Try to use the swarm executor
+    const { executeSwarm } = await import('./swarm-executor.js');
+
+    console.log(`🐝 Starting basic swarm execution...`);
+    console.log(`📋 Objective: ${objective}`);
+    console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+    console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+    console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+
     if (isHeadless) {
-        console.log('🤖 Headless environment detected - running in non-interactive mode');
-        flags = {
-            ...flags,
-            'non-interactive': true,
-            'output-format': flags['output-format'] || 'stream-json',
-            'no-auto-permissions': false
-        };
+      console.log(`🖥️  Headless Mode: Enabled`);
+      console.log(`📄 Output Format: ${flags['output-format']}`);
     }
-    // Set up graceful shutdown handlers
-    const cleanup = ()=>{
-        console.log('\n🛑 Shutting down swarm gracefully...');
-        process.exit(0);
-    };
-    process.on('SIGTERM', cleanup);
-    process.on('SIGINT', cleanup);
-    try {
-        // Try to use the swarm executor
-        const { executeSwarm } = await import("./swarm-executor.js");
-        console.log(`🐝 Starting basic swarm execution...`);
-        console.log(`📋 Objective: ${objective}`);
-        console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-        console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
-        console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
-        if (isHeadless) {
-            console.log(`🖥️  Headless Mode: Enabled`);
-            console.log(`📄 Output Format: ${flags['output-format']}`);
-        }
-        const result = await executeSwarm(objective, flags);
-        // Handle output based on format
-        if (flags['output-format'] === 'json') {
-            // In JSON mode, output clean JSON
-            const output = {
-                success: result.success,
-                swarmId: result.summary?.swarmId,
-                objective: objective,
-                duration: result.summary?.duration,
-                agents: result.summary?.totalAgents,
-                tasks: result.summary?.totalTasks,
-                timestamp: new Date().toISOString()
-            };
-            if (flags['output-file']) {
-                const fs = await import("node:fs/promises");
-                await fs.writeFile(flags['output-file'], JSON.stringify(output, null, 2));
-                console.log(`✅ Output saved to: ${flags['output-file']}`);
-            } else {
-                console.log(JSON.stringify(output, null, 2));
-            }
-        } else {
-            // Text mode output
-            if (result.success) {
-                console.log(`\n✅ Swarm execution completed successfully!`);
-                if (result.summary) {
-                    console.log(`   Duration: ${result.summary.duration}`);
-                    console.log(`   Agents: ${result.summary.totalAgents}`);
-                    console.log(`   Tasks: ${result.summary.totalTasks}`);
-                }
-            } else {
-                console.error(`\n❌ Swarm execution failed: ${result.error}`);
-            }
-        }
-        return result;
-    } catch (error) {
-        console.error(`❌ Basic swarm execution error: ${error.message}`);
-        // In headless mode, ensure we output JSON error
-        if (flags['output-format'] === 'json') {
-            const errorOutput = {
-                success: false,
-                error: error.message,
-                timestamp: new Date().toISOString()
-            };
-            console.log(JSON.stringify(errorOutput, null, 2));
+
+    const result = await executeSwarm(objective, flags);
+
+    // Handle output based on format
+    if (flags['output-format'] === 'json') {
+      // In JSON mode, output clean JSON
+      const output = {
+        success: result.success,
+        swarmId: result.summary?.swarmId,
+        objective: objective,
+        duration: result.summary?.duration,
+        agents: result.summary?.totalAgents,
+        tasks: result.summary?.totalTasks,
+        timestamp: new Date().toISOString(),
+      };
+
+      if (flags['output-file']) {
+        const fs = await import('fs/promises');
+        await fs.writeFile(flags['output-file'], JSON.stringify(output, null, 2));
+        console.log(`✅ Output saved to: ${flags['output-file']}`);
+      } else {
+        console.log(JSON.stringify(output, null, 2));
+      }
+    } else {
+      // Text mode output
+      if (result.success) {
+        console.log(`\n✅ Swarm execution completed successfully!`);
+        if (result.summary) {
+          console.log(`   Duration: ${result.summary.duration}`);
+          console.log(`   Agents: ${result.summary.totalAgents}`);
+          console.log(`   Tasks: ${result.summary.totalTasks}`);
         }
-        throw error;
+      } else {
+        console.error(`\n❌ Swarm execution failed: ${result.error}`);
+      }
     }
+
+    return result;
+  } catch (error) {
+    console.error(`❌ Basic swarm execution error: ${error.message}`);
+
+    // In headless mode, ensure we output JSON error
+    if (flags['output-format'] === 'json') {
+      const errorOutput = {
+        success: false,
+        error: error.message,
+        timestamp: new Date().toISOString(),
+      };
+      console.log(JSON.stringify(errorOutput, null, 2));
+    }
+
+    throw error;
+  }
 }
+
 function showSwarmHelp() {
-    console.log(`
+  console.log(`
 🐝 Claude Flow Advanced Swarm System
 
 USAGE:
@@ -221,114 +250,136 @@ For complete documentation and examples:
 https://github.com/ruvnet/claude-code-flow/docs/swarm.md
 `);
 }
+
 export async function swarmCommand(args, flags) {
-    // Handle headless mode early
-    if (flags && flags.headless) {
-        const isHeadless = isHeadlessEnvironment();
-        // Configure for headless mode
-        flags = {
-            ...flags,
-            'non-interactive': true,
-            'output-format': flags['output-format'] || 'stream-json',
-            'no-auto-permissions': false
-        };
-    }
-    // Handle health check first
-    if (flags && flags['health-check']) {
-        try {
-            // Quick health check for Docker/K8s
-            console.log(JSON.stringify({
-                status: 'healthy',
-                service: 'claude-flow-swarm',
-                version: process.env.npm_package_version || '2.0.0',
-                timestamp: new Date().toISOString()
-            }));
-            process.exit(0);
-        } catch (error) {
-            console.error(JSON.stringify({
-                status: 'unhealthy',
-                error: error.message,
-                timestamp: new Date().toISOString()
-            }));
-            process.exit(1);
-        }
-    }
-    const objective = (args || []).join(' ').trim();
-    if (!objective) {
-        console.error('❌ Usage: swarm <objective>');
-        showSwarmHelp();
-        return;
-    }
-    // Force headless mode if flag is set
-    if (flags && flags.headless) {
-        const isHeadless = isHeadlessEnvironment();
-        if (!isHeadless) {
-            console.log('🤖 Forcing headless mode as requested');
-        }
-        flags = {
-            ...flags,
-            'non-interactive': true,
-            'output-format': flags['output-format'] || 'json',
-            'no-auto-permissions': false
-        };
-    }
-    // Handle JSON output format
-    const outputFormat = flags && flags['output-format'];
-    const outputFile = flags && flags['output-file'];
-    const isJsonOutput = outputFormat === 'json';
-    const isNonInteractive = isJsonOutput || flags && flags['no-interactive'];
-    const useJsonLogs = flags && flags['json-logs'];
-    // Override console.log for JSON logs if requested
-    if (useJsonLogs) {
-        const originalLog = console.log;
-        const originalError = console.error;
-        console.log = (...args)=>{
-            originalLog(JSON.stringify({
-                level: 'info',
-                message: args.join(' '),
-                timestamp: new Date().toISOString(),
-                service: 'claude-flow-swarm'
-            }));
-        };
-        console.error = (...args)=>{
-            originalError(JSON.stringify({
-                level: 'error',
-                message: args.join(' '),
-                timestamp: new Date().toISOString(),
-                service: 'claude-flow-swarm'
-            }));
-        };
+  // Handle headless mode early
+  if (flags && flags.headless) {
+    const isHeadless = isHeadlessEnvironment();
+    // Configure for headless mode
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'stream-json',
+      'no-auto-permissions': false,
+    };
+  }
+
+  // Handle health check first
+  if (flags && flags['health-check']) {
+    try {
+      // Quick health check for Docker/K8s
+      console.log(
+        JSON.stringify({
+          status: 'healthy',
+          service: 'claude-flow-swarm',
+          version: process.env.npm_package_version || '2.0.0',
+          timestamp: new Date().toISOString(),
+        }),
+      );
+      process.exit(0);
+    } catch (error) {
+      console.error(
+        JSON.stringify({
+          status: 'unhealthy',
+          error: error.message,
+          timestamp: new Date().toISOString(),
+        }),
+      );
+      process.exit(1);
     }
-    // Handle analysis/read-only mode
-    const isAnalysisMode = flags && (flags.analysis || flags['read-only']);
-    const analysisMode = isAnalysisMode ? 'analysis' : 'standard';
-    // For JSON output, allow using Claude with stream-json format
-    // Only force executor mode if explicitly using 'json' format (not 'stream-json')
-    if (flags && flags['output-format'] === 'json' && !(flags && flags.executor)) {
-        // Keep backward compatibility - regular 'json' format uses executor
-        flags = {
-            ...flags || {},
-            executor: true
-        };
+  }
+
+  const objective = (args || []).join(' ').trim();
+
+  if (!objective) {
+    console.error('❌ Usage: swarm <objective>');
+    showSwarmHelp();
+    return;
+  }
+
+  // Force headless mode if flag is set
+  if (flags && flags.headless) {
+    const isHeadless = isHeadlessEnvironment();
+    if (!isHeadless) {
+      console.log('🤖 Forcing headless mode as requested');
     }
-    // Check if we should use the old executor (opt-in with --executor flag)
-    if (flags && flags.executor) {
+    flags = {
+      ...flags,
+      'non-interactive': true,
+      'output-format': flags['output-format'] || 'json',
+      'no-auto-permissions': false,
+    };
+  }
+
+  // Handle JSON output format
+  const outputFormat = flags && flags['output-format'];
+  const outputFile = flags && flags['output-file'];
+  const isJsonOutput = outputFormat === 'json';
+  const isNonInteractive = isJsonOutput || (flags && flags['no-interactive']);
+  const useJsonLogs = flags && flags['json-logs'];
+
+  // Override console.log for JSON logs if requested
+  if (useJsonLogs) {
+    const originalLog = console.log;
+    const originalError = console.error;
+
+    console.log = (...args) => {
+      originalLog(
+        JSON.stringify({
+          level: 'info',
+          message: args.join(' '),
+          timestamp: new Date().toISOString(),
+          service: 'claude-flow-swarm',
+        }),
+      );
+    };
+
+    console.error = (...args) => {
+      originalError(
+        JSON.stringify({
+          level: 'error',
+          message: args.join(' '),
+          timestamp: new Date().toISOString(),
+          service: 'claude-flow-swarm',
+        }),
+      );
+    };
+  }
+
+  // Handle analysis/read-only mode
+  const isAnalysisMode = flags && (flags.analysis || flags['read-only']);
+  const analysisMode = isAnalysisMode ? 'analysis' : 'standard';
+
+  // For JSON output, allow using Claude with stream-json format
+  // Only force executor mode if explicitly using 'json' format (not 'stream-json')
+  if (flags && flags['output-format'] === 'json' && !(flags && flags.executor)) {
+    // Keep backward compatibility - regular 'json' format uses executor
+    flags = { ...(flags || {}), executor: true };
+  }
+
+  // Check if we should use the old executor (opt-in with --executor flag)
+  if (flags && flags.executor) {
     // Continue with the old swarm executor implementation below
-    } else {
-        // Default behavior: spawn Claude Code with comprehensive swarm MCP instructions
-        try {
-            const { execSync, spawn } = await import("child_process");
-            // Get configuration values first
-            const strategy = flags.strategy || 'auto';
-            const mode = flags.mode || 'centralized';
-            const maxAgents = flags['max-agents'] || 5;
-            // Get strategy-specific guidance
-            const strategyGuidance = getStrategyGuidance(strategy, objective);
-            const modeGuidance = getModeGuidance(mode);
-            const agentRecommendations = getAgentRecommendations(strategy, maxAgents, objective);
-            const enableSparc = flags.sparc !== false && (strategy === 'development' || strategy === 'auto');
-            // Build the complete swarm prompt before checking for claude
-            const swarmPrompt = `You are orchestrating a Claude Flow Swarm using Claude Code's Task tool for agent execution.
+  } else {
+    // Default behavior: spawn Claude Code with comprehensive swarm MCP instructions
+    try {
+      const { execSync, spawn } = await import('child_process');
+
+      // Get configuration values first
+      const strategy = flags.strategy || 'auto';
+      const mode = flags.mode || 'centralized';
+      const maxAgents = flags['max-agents'] || 5;
+
+      // Get strategy-specific guidance
+      const strategyGuidance = getStrategyGuidance(strategy, objective);
+      const modeGuidance = getModeGuidance(mode);
+      const agentRecommendations = getAgentRecommendations(strategy, maxAgents, objective);
+
+      const enableSparc =
+        flags.sparc !== false && (strategy === 'development' || strategy === 'auto');
+
+      // Build the complete swarm prompt before checking for claude
+      const swarmPrompt = `You are orchestrating a Claude Flow Swarm using Claude Code's Task tool for agent execution.
 
 🚨 CRITICAL INSTRUCTION: Use Claude Code's Task Tool for ALL Agent Spawning!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -348,7 +399,9 @@ export async function swarmCommand(args, flags) {
 - Testing Mode: ${flags.testing || false}
 - Analysis Mode: ${isAnalysisMode ? 'ENABLED (Read-Only)' : 'DISABLED'}
 
-${isAnalysisMode ? `🔍 ANALYSIS MODE CONSTRAINTS:
+${
+  isAnalysisMode
+    ? `🔍 ANALYSIS MODE CONSTRAINTS:
 
 ⚠️  READ-ONLY MODE ACTIVE - NO CODE MODIFICATIONS ALLOWED
 
@@ -381,7 +434,9 @@ ALL AGENTS MUST OPERATE IN READ-ONLY MODE. Focus on:
 
 Generate comprehensive reports instead of making changes.
 
-` : ''}🚨 CRITICAL: PARALLEL EXECUTION IS MANDATORY! 🚨
+`
+    : ''
+}🚨 CRITICAL: PARALLEL EXECUTION IS MANDATORY! 🚨
 
 📋 CLAUDE-FLOW SWARM BATCHTOOL INSTRUCTIONS
 
@@ -592,7 +647,9 @@ ${agentRecommendations}
    - Tools: agent_communicate, memory_store/retrieve
 
 ⚡ EXECUTION WORKFLOW - ALWAYS USE BATCHTOOL:
-${enableSparc ? `
+${
+  enableSparc
+    ? `
 1. SPARC METHODOLOGY WITH PARALLEL EXECUTION:
    
    S - Specification Phase (Single BatchTool):
@@ -640,7 +697,8 @@ ${enableSparc ? `
      mcp__claude-flow__memory_retrieve { pattern: "**/*" }
      TodoWrite { todos: [{content: "Final review", status: "completed"}] }
    \`\`\`
-` : `
+`
+    : `
 1. STANDARD SWARM EXECUTION WITH PARALLEL OPERATIONS:
    
    Initial Setup (Single BatchTool):
@@ -668,7 +726,8 @@ ${enableSparc ? `
      mcp__claude-flow__agent_communicate { to: "all", message: "Status update" }
      mcp__claude-flow__memory_store { key: "progress", value: {...} }
    \`\`\`
-`}
+`
+}
 
 🤝 AGENT TYPES & THEIR MCP TOOL USAGE:
 
@@ -733,207 +792,243 @@ Use hierarchical keys for organization:
 Start by spawning a coordinator agent and creating the initial task structure. Use the MCP tools to orchestrate the swarm, coordinate agents, and track progress. Remember to store important decisions and artifacts in collective memory for other agents to access.
 
 The swarm should be self-documenting - use memory_store to save all important information, decisions, and results throughout the execution.`;
-            // If --claude flag is used, force Claude Code even if CLI not available
-            if (flags && flags.claude) {
-                // --claude flag means interactive mode, so don't apply non-interactive
-                console.log('🐝 Launching Claude Flow Swarm System...');
-                console.log(`📋 Objective: ${objective}`);
-                console.log(`🎯 Strategy: ${strategy}`);
-                console.log(`🏗️  Mode: ${mode}`);
-                console.log(`🤖 Max Agents: ${maxAgents}\n`);
-                console.log('🚀 Launching Claude Code with Swarm Coordination');
-                console.log('─'.repeat(60));
-                // Build arguments properly: for interactive mode, prompt can be first
-                const claudeArgs = [];
-                // Add auto-permission flag first
-                if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
-                    claudeArgs.push('--dangerously-skip-permissions');
-                    console.log('🔓 Using --dangerously-skip-permissions by default for seamless swarm execution');
-                }
-                // Add the prompt (for interactive mode, position doesn't matter as much)
-                claudeArgs.push(swarmPrompt);
-                // --claude flag means interactive mode, so don't add non-interactive flags
-                // For --claude interactive mode, spawn Claude directly
-                // Temporarily disable telemetry to avoid console output interference
-                const claudeEnv = {
-                    ...process.env
-                };
-                // Remove telemetry env vars to prevent console output
-                delete claudeEnv.CLAUDE_CODE_ENABLE_TELEMETRY;
-                delete claudeEnv.OTEL_METRICS_EXPORTER;
-                delete claudeEnv.OTEL_LOGS_EXPORTER;
-                const claudeProcess = spawn('claude', claudeArgs, {
-                    stdio: 'inherit',
-                    shell: false,
-                    env: claudeEnv
-                });
-                console.log('\n✓ Claude Code launched with swarm coordination prompt!');
-                console.log('  The swarm coordinator will orchestrate all agent tasks');
-                console.log('  Use MCP tools for coordination and memory sharing');
-                console.log('\n💡 Pro Tips:');
-                console.log('─'.repeat(30));
-                console.log('• Use TodoWrite to track parallel tasks');
-                console.log('• Store results with mcp__claude-flow__memory_usage');
-                console.log('• Monitor progress with mcp__claude-flow__swarm_monitor');
-                console.log('• Check task status with mcp__claude-flow__task_status');
-                // Set up clean termination
-                const cleanup = ()=>{
-                    console.log('\n🛑 Shutting down swarm gracefully...');
-                    if (claudeProcess && !claudeProcess.killed) {
-                        claudeProcess.kill('SIGTERM');
-                    }
-                    process.exit(0);
-                };
-                process.on('SIGINT', cleanup);
-                process.on('SIGTERM', cleanup);
-                // Wait for claude to exit
-                claudeProcess.on('exit', (code)=>{
-                    if (code === 0) {
-                        console.log('\n✓ Swarm execution completed successfully');
-                    } else if (code !== null) {
-                        console.log(`\n✗ Swarm execution exited with code ${code}`);
-                    }
-                    process.exit(code || 0);
-                });
-                // Handle spawn errors (e.g., claude not found)
-                claudeProcess.on('error', (err)=>{
-                    if (err.code === 'ENOENT') {
-                        console.error('\n❌ Claude Code CLI not found. Please install Claude Code:');
-                        console.error('   https://claude.ai/download');
-                    } else {
-                        console.error('\n❌ Failed to launch Claude Code:', err.message);
-                    }
-                    process.exit(1);
-                });
-                return;
-            }
-            // Check if we're in non-interactive/headless mode FIRST (like alpha.83)
-            const isNonInteractive = flags['no-interactive'] || flags['non-interactive'] || flags['output-format'] === 'stream-json' || isHeadlessEnvironment();
-            // Check if claude command exists
-            let claudeAvailable = false;
-            try {
-                execSync('which claude', {
-                    stdio: 'ignore'
-                });
-                claudeAvailable = true;
-            } catch  {
-                if (!isNonInteractive) {
-                    console.log('⚠️  Claude Code CLI not found in PATH');
-                    console.log('Install it with: npm install -g @anthropic-ai/claude-code');
-                    console.log('Or use --claude flag to open Claude Code CLI');
-                    console.log('\nWould spawn Claude Code with swarm objective:');
-                    console.log(`📋 Objective: ${objective}`);
-                    console.log('\nOptions:');
-                    console.log('  • Use --executor flag for built-in executor: claude-flow-novice swarm "objective" --executor');
-                    console.log('  • Use --claude flag to open Claude Code CLI: claude-flow-novice swarm "objective" --claude');
-                } else {
-                    // In non-interactive mode, output JSON error
-                    console.error(JSON.stringify({
-                        error: 'Claude Code CLI not found',
-                        message: 'Install with: npm install -g @anthropic-ai/claude-code',
-                        fallback: 'Use --executor flag for built-in executor'
-                    }));
-                }
-                return;
-            }
-            // Claude is available, use it to run swarm
-            if (!isNonInteractive) {
-                console.log('🐝 Launching Claude Flow Swarm System...');
-                console.log(`📋 Objective: ${objective}`);
-                console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-                console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
-                console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
-                if (isAnalysisMode) {
-                    console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
-                }
-                console.log();
-            } else {
-                // Non-interactive mode output
-                console.log('🤖 Running in non-interactive mode with Claude');
-                console.log('📋 Command: claude [prompt] -p --output-format stream-json --verbose');
-            }
-            // Continue with the default swarm behavior if not using --claude flag
-            // Build arguments in correct order: flags first, then prompt
-            const claudeArgs = [];
-            // Add non-interactive flags FIRST if needed
-            if (isNonInteractive) {
-                claudeArgs.push('-p'); // Print mode
-                claudeArgs.push('--output-format', 'stream-json'); // JSON streaming
-                claudeArgs.push('--verbose'); // Verbose output
-            }
-            // Add auto-permission flag BEFORE the prompt
-            if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
-                claudeArgs.push('--dangerously-skip-permissions');
-                if (!isNonInteractive) {
-                    console.log('🔓 Using --dangerously-skip-permissions by default for seamless swarm execution');
-                }
-            }
-            // Add the prompt as the LAST argument
-            claudeArgs.push(swarmPrompt);
-            // Spawn claude with properly ordered arguments
-            const claudeProcess = spawn('claude', claudeArgs, {
-                stdio: 'inherit',
-                shell: false
-            });
-            if (!isNonInteractive) {
-                console.log('✓ Claude Code launched with swarm coordination prompt!');
-                console.log('\n🚀 The swarm coordination instructions have been injected into Claude Code');
-                console.log('   The prompt includes:');
-                console.log('   • Strategy-specific guidance for', strategy);
-                console.log('   • Coordination patterns for', mode, 'mode');
-                console.log('   • Recommended agents and MCP tool usage');
-                console.log('   • Complete workflow documentation\n');
-            }
-            // Handle process events
-            claudeProcess.on('error', (err)=>{
-                console.error('❌ Failed to launch Claude Code:', err.message);
-            });
-            // Don't wait for completion - let it run
-            return;
-        } catch (error) {
-            console.error('❌ Failed to spawn Claude Code:', error.message);
-            console.log('\nFalling back to built-in executor...');
-        // Fall through to executor implementation
+
+      // If --claude flag is used, force Claude Code even if CLI not available
+      if (flags && flags.claude) {
+        // --claude flag means interactive mode, so don't apply non-interactive
+        console.log('🐝 Launching Claude Flow Swarm System...');
+        console.log(`📋 Objective: ${objective}`);
+        console.log(`🎯 Strategy: ${strategy}`);
+        console.log(`🏗️  Mode: ${mode}`);
+        console.log(`🤖 Max Agents: ${maxAgents}\n`);
+
+        console.log('🚀 Launching Claude Code with Swarm Coordination');
+        console.log('─'.repeat(60));
+
+        // Build arguments properly: for interactive mode, prompt can be first
+        const claudeArgs = [];
+
+        // Add auto-permission flag first
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+          claudeArgs.push('--dangerously-skip-permissions');
+          console.log(
+            '🔓 Using --dangerously-skip-permissions by default for seamless swarm execution',
+          );
         }
+
+        // Add the prompt (for interactive mode, position doesn't matter as much)
+        claudeArgs.push(swarmPrompt);
+
+        // --claude flag means interactive mode, so don't add non-interactive flags
+
+        // For --claude interactive mode, spawn Claude directly
+        // Temporarily disable telemetry to avoid console output interference
+        const claudeEnv = { ...process.env };
+
+        // Remove telemetry env vars to prevent console output
+        delete claudeEnv.CLAUDE_CODE_ENABLE_TELEMETRY;
+        delete claudeEnv.OTEL_METRICS_EXPORTER;
+        delete claudeEnv.OTEL_LOGS_EXPORTER;
+
+        const claudeProcess = spawn('claude', claudeArgs, {
+          stdio: 'inherit',
+          shell: false,
+          env: claudeEnv,
+        });
+
+        console.log('\n✓ Claude Code launched with swarm coordination prompt!');
+        console.log('  The swarm coordinator will orchestrate all agent tasks');
+        console.log('  Use MCP tools for coordination and memory sharing');
+
+        console.log('\n💡 Pro Tips:');
+        console.log('─'.repeat(30));
+        console.log('• Use TodoWrite to track parallel tasks');
+        console.log('• Store results with mcp__claude-flow__memory_usage');
+        console.log('• Monitor progress with mcp__claude-flow__swarm_monitor');
+        console.log('• Check task status with mcp__claude-flow__task_status');
+
+        // Set up clean termination
+        const cleanup = () => {
+          console.log('\n🛑 Shutting down swarm gracefully...');
+          if (claudeProcess && !claudeProcess.killed) {
+            claudeProcess.kill('SIGTERM');
+          }
+          process.exit(0);
+        };
+
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+
+        // Wait for claude to exit
+        claudeProcess.on('exit', (code) => {
+          if (code === 0) {
+            console.log('\n✓ Swarm execution completed successfully');
+          } else if (code !== null) {
+            console.log(`\n✗ Swarm execution exited with code ${code}`);
+          }
+          process.exit(code || 0);
+        });
+
+        // Handle spawn errors (e.g., claude not found)
+        claudeProcess.on('error', (err) => {
+          if (err.code === 'ENOENT') {
+            console.error('\n❌ Claude Code CLI not found. Please install Claude Code:');
+            console.error('   https://claude.ai/download');
+          } else {
+            console.error('\n❌ Failed to launch Claude Code:', err.message);
+          }
+          process.exit(1);
+        });
+
+        return;
+      }
+
+      // Check if we're in non-interactive/headless mode FIRST (like alpha.83)
+      const isNonInteractive =
+        flags['no-interactive'] ||
+        flags['non-interactive'] ||
+        flags['output-format'] === 'stream-json' ||
+        isHeadlessEnvironment();
+
+      // Check if claude command exists
+      let claudeAvailable = false;
+      try {
+        execSync('which claude', { stdio: 'ignore' });
+        claudeAvailable = true;
+      } catch {
+        if (!isNonInteractive) {
+          console.log('⚠️  Claude Code CLI not found in PATH');
+          console.log('Install it with: npm install -g @anthropic-ai/claude-code');
+          console.log('Or use --claude flag to open Claude Code CLI');
+          console.log('\nWould spawn Claude Code with swarm objective:');
+          console.log(`📋 Objective: ${objective}`);
+          console.log('\nOptions:');
+          console.log(
+            '  • Use --executor flag for built-in executor: claude-flow-novice swarm "objective" --executor',
+          );
+          console.log(
+            '  • Use --claude flag to open Claude Code CLI: claude-flow-novice swarm "objective" --claude',
+          );
+        } else {
+          // In non-interactive mode, output JSON error
+          console.error(
+            JSON.stringify({
+              error: 'Claude Code CLI not found',
+              message: 'Install with: npm install -g @anthropic-ai/claude-code',
+              fallback: 'Use --executor flag for built-in executor',
+            }),
+          );
+        }
+        return;
+      }
+
+      // Claude is available, use it to run swarm
+      if (!isNonInteractive) {
+        console.log('🐝 Launching Claude Flow Swarm System...');
+        console.log(`📋 Objective: ${objective}`);
+        console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+        console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+        console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+        if (isAnalysisMode) {
+          console.log(`🔍 Analysis Mode: ENABLED (Read-Only - No Code Changes)`);
+        }
+        console.log();
+      } else {
+        // Non-interactive mode output
+        console.log('🤖 Running in non-interactive mode with Claude');
+        console.log('📋 Command: claude [prompt] -p --output-format stream-json --verbose');
+      }
+
+      // Continue with the default swarm behavior if not using --claude flag
+
+      // Build arguments in correct order: flags first, then prompt
+      const claudeArgs = [];
+
+      // Add non-interactive flags FIRST if needed
+      if (isNonInteractive) {
+        claudeArgs.push('-p'); // Print mode
+        claudeArgs.push('--output-format', 'stream-json'); // JSON streaming
+        claudeArgs.push('--verbose'); // Verbose output
+      }
+
+      // Add auto-permission flag BEFORE the prompt
+      if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+        claudeArgs.push('--dangerously-skip-permissions');
+        if (!isNonInteractive) {
+          console.log(
+            '🔓 Using --dangerously-skip-permissions by default for seamless swarm execution',
+          );
+        }
+      }
+
+      // Add the prompt as the LAST argument
+      claudeArgs.push(swarmPrompt);
+
+      // Spawn claude with properly ordered arguments
+      const claudeProcess = spawn('claude', claudeArgs, {
+        stdio: 'inherit',
+        shell: false,
+      });
+
+      if (!isNonInteractive) {
+        console.log('✓ Claude Code launched with swarm coordination prompt!');
+        console.log('\n🚀 The swarm coordination instructions have been injected into Claude Code');
+        console.log('   The prompt includes:');
+        console.log('   • Strategy-specific guidance for', strategy);
+        console.log('   • Coordination patterns for', mode, 'mode');
+        console.log('   • Recommended agents and MCP tool usage');
+        console.log('   • Complete workflow documentation\n');
+      }
+
+      // Handle process events
+      claudeProcess.on('error', (err) => {
+        console.error('❌ Failed to launch Claude Code:', err.message);
+      });
+
+      // Don't wait for completion - let it run
+      return;
+    } catch (error) {
+      console.error('❌ Failed to spawn Claude Code:', error.message);
+      console.log('\nFalling back to built-in executor...');
+      // Fall through to executor implementation
     }
-    // Check if we should run in background mode
-    if (flags && flags.background && !process.env.CLAUDE_SWARM_NO_BG) {
-        // Check if we're in Deno environment
-        if (typeof Deno !== 'undefined') {
-            // In Deno, spawn a new process for true background execution
-            const objective = (args || []).join(' ').trim();
-            const swarmId = `swarm_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-            const swarmRunDir = `./swarm-runs/${swarmId}`;
-            // Create swarm directory
-            await mkdirAsync(swarmRunDir, {
-                recursive: true
-            });
-            console.log(`🐝 Launching swarm in background mode...`);
-            console.log(`📋 Objective: ${objective}`);
-            console.log(`🆔 Swarm ID: ${swarmId}`);
-            console.log(`📁 Results: ${swarmRunDir}`);
-            // Build command args without background flag (to prevent infinite loop)
-            const commandArgs = [
-                'run',
-                '--allow-all',
-                import.meta.url,
-                objective
-            ];
-            const newFlags = {
-                ...flags
-            };
-            delete newFlags.background; // Remove background flag
-            for (const [key, value] of Object.entries(newFlags)){
-                commandArgs.push(`--${key}`);
-                if (value !== true) {
-                    commandArgs.push(String(value));
-                }
-            }
-            // Create log file
-            const logFile = `${swarmRunDir}/swarm.log`;
-            const logHandle = await open(logFile, 'w');
-            // Create a script to run the swarm without background flag
-            const scriptContent = `#!/usr/bin/env -S deno run --allow-all
+  }
+
+  // Check if we should run in background mode
+  if (flags && flags.background && !process.env.CLAUDE_SWARM_NO_BG) {
+    // Check if we're in Deno environment
+    if (typeof Deno !== 'undefined') {
+      // In Deno, spawn a new process for true background execution
+      const objective = (args || []).join(' ').trim();
+      const swarmId = `swarm_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      const swarmRunDir = `./swarm-runs/${swarmId}`;
+
+      // Create swarm directory
+      await mkdirAsync(swarmRunDir, { recursive: true });
+
+      console.log(`🐝 Launching swarm in background mode...`);
+      console.log(`📋 Objective: ${objective}`);
+      console.log(`🆔 Swarm ID: ${swarmId}`);
+      console.log(`📁 Results: ${swarmRunDir}`);
+
+      // Build command args without background flag (to prevent infinite loop)
+      const commandArgs = ['run', '--allow-all', import.meta.url, objective];
+      const newFlags = { ...flags };
+      delete newFlags.background; // Remove background flag
+
+      for (const [key, value] of Object.entries(newFlags)) {
+        commandArgs.push(`--${key}`);
+        if (value !== true) {
+          commandArgs.push(String(value));
+        }
+      }
+
+      // Create log file
+      const logFile = `${swarmRunDir}/swarm.log`;
+      const logHandle = await open(logFile, 'w');
+
+      // Create a script to run the swarm without background flag
+      const scriptContent = `#!/usr/bin/env -S deno run --allow-all
 import { swarmCommand } from "${import.meta.url}";
 import { cwd, exit, existsSync } from '../node-compat.js';
 import process from 'process';
@@ -948,53 +1043,64 @@ process.env.CLAUDE_SWARM_NO_BG = 'true';
 // Run the swarm
 await swarmCommand(args, flags);
 `;
-            const scriptPath = `${swarmRunDir}/run-swarm.js`;
-            await writeTextFile(scriptPath, scriptContent);
-            // Save process info first
-            await writeTextFile(`${swarmRunDir}/process.json`, JSON.stringify({
-                swarmId: swarmId,
-                objective: objective,
-                startTime: new Date().toISOString(),
-                logFile: logFile,
-                status: 'starting'
-            }, null, 2));
-            // Close log handle before spawning
-            logHandle.close();
-            // Use the bash script for true background execution
-            const binDir = new URL('../../../bin/', import.meta.url).pathname;
-            const bgScriptPath = `${binDir}claude-flow-swarm-bg`;
-            try {
-                // Check if the background script exists
-                statSync(bgScriptPath);
-                // Build command args for the background script
-                const bgArgs = [
-                    objective
-                ];
-                for (const [key, value] of Object.entries(newFlags)){
-                    bgArgs.push(`--${key}`);
-                    if (value !== true) {
-                        bgArgs.push(String(value));
-                    }
-                }
-                // Use the bash background script
-                const bgProcess = spawn(bgScriptPath, bgArgs, {
-                    stdio: [
-                        'ignore',
-                        'pipe',
-                        'pipe'
-                    ]
-                });
-                // Read and display output
-                const decoder = new TextDecoder();
-                const output = await bgProcess.output();
-                console.log(decoder.decode(output.stdout));
-                // Exit immediately after launching
-                exit(0);
-            } catch (error) {
-                // Fallback: create a double-fork pattern using a shell script
-                console.log(`\n⚠️  Background script not found, using fallback method`);
-                // Create a shell script that will run the swarm
-                const shellScript = `#!/bin/bash
+
+      const scriptPath = `${swarmRunDir}/run-swarm.js`;
+      await writeTextFile(scriptPath, scriptContent);
+
+      // Save process info first
+      await writeTextFile(
+        `${swarmRunDir}/process.json`,
+        JSON.stringify(
+          {
+            swarmId: swarmId,
+            objective: objective,
+            startTime: new Date().toISOString(),
+            logFile: logFile,
+            status: 'starting',
+          },
+          null,
+          2,
+        ),
+      );
+
+      // Close log handle before spawning
+      logHandle.close();
+
+      // Use the bash script for true background execution
+      const binDir = new URL('../../../bin/', import.meta.url).pathname;
+      const bgScriptPath = `${binDir}claude-flow-swarm-bg`;
+
+      try {
+        // Check if the background script exists
+        statSync(bgScriptPath);
+
+        // Build command args for the background script
+        const bgArgs = [objective];
+        for (const [key, value] of Object.entries(newFlags)) {
+          bgArgs.push(`--${key}`);
+          if (value !== true) {
+            bgArgs.push(String(value));
+          }
+        }
+
+        // Use the bash background script
+        const bgProcess = spawn(bgScriptPath, bgArgs, {
+          stdio: ['ignore', 'pipe', 'pipe'],
+        });
+
+        // Read and display output
+        const decoder = new TextDecoder();
+        const output = await bgProcess.output();
+        console.log(decoder.decode(output.stdout));
+
+        // Exit immediately after launching
+        exit(0);
+      } catch (error) {
+        // Fallback: create a double-fork pattern using a shell script
+        console.log(`\n⚠️  Background script not found, using fallback method`);
+
+        // Create a shell script that will run the swarm
+        const shellScript = `#!/bin/bash
 # Double fork to detach from parent
 (
   (
@@ -1004,231 +1110,262 @@ await swarmCommand(args, flags);
 )
 exit 0
 `;
-                const shellScriptPath = `${swarmRunDir}/launch-background.sh`;
-                await writeTextFile(shellScriptPath, shellScript);
-                chmodSync(shellScriptPath, 0o755);
-                // Execute the shell script
-                const shellProcess = spawn('bash', [
-                    shellScriptPath
-                ], {
-                    stdio: 'ignore',
-                    detached: true
-                });
-                shellProcess.unref();
-                console.log(`\n✅ Swarm launched in background!`);
-                console.log(`📄 Logs: tail -f ${logFile}`);
-                console.log(`📊 Status: claude-flow-novice swarm status ${swarmId}`);
-                console.log(`\nThe swarm will continue running independently.`);
-                // Exit immediately
-                exit(0);
-            }
-        }
-        // Node.js environment - use background script
-        const { execSync } = await import("child_process");
-        const path = await import("path");
-        const fs = await import("fs");
-        const objective = (args || []).join(' ').trim();
-        // Get the claude-flow-swarm-bg script path
-        const bgScriptPath = path.join(path.dirname(new URL(import.meta.url).pathname), '../../../bin/claude-flow-swarm-bg');
-        // Check if background script exists
-        if (fs.existsSync(bgScriptPath)) {
-            // Build command args
-            const commandArgs = [
-                objective
-            ];
-            for (const [key, value] of Object.entries(flags)){
-                if (key !== 'background') {
-                    // Skip background flag
-                    commandArgs.push(`--${key}`);
-                    if (value !== true) {
-                        commandArgs.push(String(value));
-                    }
-                }
-            }
-            // Execute the background script
-            try {
-                execSync(`"${bgScriptPath}" ${commandArgs.map((arg)=>`"${arg}"`).join(' ')}`, {
-                    stdio: 'inherit'
-                });
-            } catch (error) {
-                console.error('Failed to launch background swarm:', error.message);
-            }
-        } else {
-            // Fallback to simple message
-            console.log(`🐝 Background mode requested`);
-            console.log(`📋 Objective: ${objective}`);
-            console.log(`\n⚠️  Background execution requires the claude-flow-swarm-bg script.`);
-            console.log(`\nFor true background execution, use:`);
-            console.log(`  nohup claude-flow-novice swarm "${objective}" ${Object.entries(flags).filter(([k, v])=>k !== 'background' && v).map(([k, v])=>`--${k}${v !== true ? ` ${v}` : ''}`).join(' ')} > swarm.log 2>&1 &`);
+
+        const shellScriptPath = `${swarmRunDir}/launch-background.sh`;
+        await writeTextFile(shellScriptPath, shellScript);
+        chmodSync(shellScriptPath, 0o755);
+
+        // Execute the shell script
+        const shellProcess = spawn('bash', [shellScriptPath], {
+          stdio: 'ignore',
+          detached: true,
+        });
+        shellProcess.unref();
+
+        console.log(`\n✅ Swarm launched in background!`);
+        console.log(`📄 Logs: tail -f ${logFile}`);
+        console.log(`📊 Status: claude-flow-novice swarm status ${swarmId}`);
+        console.log(`\nThe swarm will continue running independently.`);
+
+        // Exit immediately
+        exit(0);
+      }
+    }
+
+    // Node.js environment - use background script
+    const { execSync } = await import('child_process');
+    const path = await import('path');
+    const fs = await import('fs');
+
+    const objective = (args || []).join(' ').trim();
+
+    // Get the claude-flow-swarm-bg script path
+    const bgScriptPath = path.join(
+      path.dirname(new URL(import.meta.url).pathname),
+      '../../../bin/claude-flow-swarm-bg',
+    );
+
+    // Check if background script exists
+    if (fs.existsSync(bgScriptPath)) {
+      // Build command args
+      const commandArgs = [objective];
+      for (const [key, value] of Object.entries(flags)) {
+        if (key !== 'background') {
+          // Skip background flag
+          commandArgs.push(`--${key}`);
+          if (value !== true) {
+            commandArgs.push(String(value));
+          }
         }
-        return;
+      }
+
+      // Execute the background script
+      try {
+        execSync(`"${bgScriptPath}" ${commandArgs.map((arg) => `"${arg}"`).join(' ')}`, {
+          stdio: 'inherit',
+        });
+      } catch (error) {
+        console.error('Failed to launch background swarm:', error.message);
+      }
+    } else {
+      // Fallback to simple message
+      console.log(`🐝 Background mode requested`);
+      console.log(`📋 Objective: ${objective}`);
+      console.log(`\n⚠️  Background execution requires the claude-flow-swarm-bg script.`);
+      console.log(`\nFor true background execution, use:`);
+      console.log(
+        `  nohup claude-flow-novice swarm "${objective}" ${Object.entries(flags)
+          .filter(([k, v]) => k !== 'background' && v)
+          .map(([k, v]) => `--${k}${v !== true ? ` ${v}` : ''}`)
+          .join(' ')} > swarm.log 2>&1 &`,
+      );
     }
+    return;
+  }
+
+  try {
+    // Try to load the compiled JavaScript module first
+    let swarmAction;
     try {
-        // Try to load the compiled JavaScript module first
-        let swarmAction;
+      // Try the compiled version first (for production/npm packages)
+      const distPath = new URL('../../../dist/cli/commands/swarm-new.js', import.meta.url);
+      const module = await import(distPath);
+      swarmAction = module.swarmAction;
+    } catch (distError) {
+      // Instead of immediately falling back to basic mode,
+      // continue to the Claude integration below
+      console.log('📦 Compiled swarm module not found, checking for Claude CLI...');
+    }
+
+    // Only call swarmAction if it was successfully loaded
+    if (swarmAction) {
+      // Create command context compatible with TypeScript version
+      const ctx = {
+        args: args || [],
+        flags: flags || {},
+        command: 'swarm',
+      };
+
+      await swarmAction(ctx);
+      return; // Exit after successful execution
+    }
+  } catch (error) {
+    // If import fails (e.g., in node_modules), provide inline implementation
+    if (
+      error.code === 'ERR_MODULE_NOT_FOUND' ||
+      error.code === 'ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING' ||
+      error.code === 'ERR_UNKNOWN_FILE_EXTENSION'
+    ) {
+      // Provide a basic swarm implementation that works without TypeScript imports
+      const objective = (args || []).join(' ').trim();
+
+      if (!objective) {
+        console.error('❌ Usage: swarm <objective>');
+        showSwarmHelp();
+        return;
+      }
+
+      // Try to use the swarm executor directly
+      try {
+        const { executeSwarm } = await import('./swarm-executor.js');
+        const result = await executeSwarm(objective, flags);
+
+        // If execution was successful, exit
+        if (result && result.success) {
+          return;
+        }
+      } catch (execError) {
+        console.log(`⚠️  Swarm executor error: ${execError.message}`);
+        // If swarm executor fails, try to create files directly
         try {
-            // Try the compiled version first (for production/npm packages)
-            const distPath = new URL('../../../dist/cli/commands/swarm-new.js', import.meta.url);
-            const module = await import(distPath);
-            swarmAction = module.swarmAction;
-        } catch (distError) {
-            // Instead of immediately falling back to basic mode,
-            // continue to the Claude integration below
-            console.log('📦 Compiled swarm module not found, checking for Claude CLI...');
+          await createSwarmFiles(objective, flags);
+          return;
+        } catch (createError) {
+          console.log(`⚠️  Direct file creation error: ${createError.message}`);
+          // Continue with fallback implementation
         }
-        // Only call swarmAction if it was successfully loaded
-        if (swarmAction) {
-            // Create command context compatible with TypeScript version
-            const ctx = {
-                args: args || [],
-                flags: flags || {},
-                command: 'swarm'
-            };
-            await swarmAction(ctx);
-            return; // Exit after successful execution
+      }
+
+      // Provide a basic inline swarm implementation for npm packages
+      console.log('🐝 Launching swarm system...');
+      console.log(`📋 Objective: ${objective}`);
+      console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+      console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
+      console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
+      console.log();
+
+      // Generate swarm ID
+      const swarmId = `swarm_${Math.random().toString(36).substring(2, 11)}_${Math.random().toString(36).substring(2, 11)}`;
+
+      if (flags['dry-run']) {
+        console.log(`🆔 Swarm ID: ${swarmId}`);
+        console.log(`📊 Max Tasks: ${flags['max-tasks'] || 100}`);
+        console.log(`⏰ Timeout: ${flags.timeout || 60} minutes`);
+        console.log(`🔄 Parallel: ${flags.parallel || false}`);
+        console.log(`🌐 Distributed: ${flags.distributed || false}`);
+        console.log(`🔍 Monitoring: ${flags.monitor || false}`);
+        console.log(`👥 Review Mode: ${flags.review || false}`);
+        console.log(`🧪 Testing: ${flags.testing || false}`);
+        console.log(`🧠 Memory Namespace: ${flags['memory-namespace'] || 'swarm'}`);
+        console.log(`💾 Persistence: ${flags.persistence !== false}`);
+        console.log(`🔒 Encryption: ${flags.encryption || false}`);
+        console.log(`📊 Quality Threshold: ${flags['quality-threshold'] || 0.8}`);
+        console.log();
+        console.log('🎛️  Coordination Strategy:');
+        console.log(`  • Agent Selection: ${flags['agent-selection'] || 'capability-based'}`);
+        console.log(`  • Task Scheduling: ${flags['task-scheduling'] || 'priority'}`);
+        console.log(`  • Load Balancing: ${flags['load-balancing'] || 'work-stealing'}`);
+        console.log(`  • Fault Tolerance: ${flags['fault-tolerance'] || 'retry'}`);
+        console.log(`  • Communication: ${flags.communication || 'event-driven'}`);
+        console.log('⚠️  DRY RUN - Advanced Swarm Configuration');
+        return;
+      }
+
+      // For actual execution in npm context, try to find and run swarm-demo.ts
+      try {
+        const path = await import('path');
+        const { fileURLToPath } = await import('url');
+        const fs = await import('fs');
+        const { spawn } = await import('child_process');
+
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+
+        // Look for swarm-demo.ts in the package
+        const possiblePaths = [
+          path.join(__dirname, '../../../swarm-demo.ts'),
+          path.join(__dirname, '../../swarm-demo.ts'),
+        ];
+
+        let swarmDemoPath = null;
+        for (const p of possiblePaths) {
+          if (fs.existsSync(p)) {
+            swarmDemoPath = p;
+            break;
+          }
         }
-    } catch (error) {
-        // If import fails (e.g., in node_modules), provide inline implementation
-        if (error.code === 'ERR_MODULE_NOT_FOUND' || error.code === 'ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING' || error.code === 'ERR_UNKNOWN_FILE_EXTENSION') {
-            // Provide a basic swarm implementation that works without TypeScript imports
-            const objective = (args || []).join(' ').trim();
-            if (!objective) {
-                console.error('❌ Usage: swarm <objective>');
-                showSwarmHelp();
-                return;
-            }
-            // Try to use the swarm executor directly
-            try {
-                const { executeSwarm } = await import("./swarm-executor.js");
-                const result = await executeSwarm(objective, flags);
-                // If execution was successful, exit
-                if (result && result.success) {
-                    return;
-                }
-            } catch (execError) {
-                console.log(`⚠️  Swarm executor error: ${execError.message}`);
-                // If swarm executor fails, try to create files directly
-                try {
-                    await createSwarmFiles(objective, flags);
-                    return;
-                } catch (createError) {
-                    console.log(`⚠️  Direct file creation error: ${createError.message}`);
-                // Continue with fallback implementation
-                }
-            }
-            // Provide a basic inline swarm implementation for npm packages
-            console.log('🐝 Launching swarm system...');
-            console.log(`📋 Objective: ${objective}`);
-            console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-            console.log(`🏗️  Mode: ${flags.mode || 'centralized'}`);
-            console.log(`🤖 Max Agents: ${flags['max-agents'] || 5}`);
-            console.log();
-            // Generate swarm ID
-            const swarmId = `swarm_${Math.random().toString(36).substring(2, 11)}_${Math.random().toString(36).substring(2, 11)}`;
-            if (flags['dry-run']) {
-                console.log(`🆔 Swarm ID: ${swarmId}`);
-                console.log(`📊 Max Tasks: ${flags['max-tasks'] || 100}`);
-                console.log(`⏰ Timeout: ${flags.timeout || 60} minutes`);
-                console.log(`🔄 Parallel: ${flags.parallel || false}`);
-                console.log(`🌐 Distributed: ${flags.distributed || false}`);
-                console.log(`🔍 Monitoring: ${flags.monitor || false}`);
-                console.log(`👥 Review Mode: ${flags.review || false}`);
-                console.log(`🧪 Testing: ${flags.testing || false}`);
-                console.log(`🧠 Memory Namespace: ${flags['memory-namespace'] || 'swarm'}`);
-                console.log(`💾 Persistence: ${flags.persistence !== false}`);
-                console.log(`🔒 Encryption: ${flags.encryption || false}`);
-                console.log(`📊 Quality Threshold: ${flags['quality-threshold'] || 0.8}`);
-                console.log();
-                console.log('🎛️  Coordination Strategy:');
-                console.log(`  • Agent Selection: ${flags['agent-selection'] || 'capability-based'}`);
-                console.log(`  • Task Scheduling: ${flags['task-scheduling'] || 'priority'}`);
-                console.log(`  • Load Balancing: ${flags['load-balancing'] || 'work-stealing'}`);
-                console.log(`  • Fault Tolerance: ${flags['fault-tolerance'] || 'retry'}`);
-                console.log(`  • Communication: ${flags.communication || 'event-driven'}`);
-                console.log('⚠️  DRY RUN - Advanced Swarm Configuration');
-                return;
+
+        if (swarmDemoPath && Deno) {
+          // Run swarm-demo.ts directly with Deno
+          const swarmArgs = [objective];
+          for (const [key, value] of Object.entries(flags || {})) {
+            swarmArgs.push(`--${key}`);
+            if (value !== true) {
+              swarmArgs.push(String(value));
             }
-            // For actual execution in npm context, try to find and run swarm-demo.ts
-            try {
-                const path = await import("path");
-                const { fileURLToPath } = await import("url");
-                const fs = await import("fs");
-                const { spawn } = await import("child_process");
-                const __filename = fileURLToPath(import.meta.url);
-                const __dirname = path.dirname(__filename);
-                // Look for swarm-demo.ts in the package
-                const possiblePaths = [
-                    path.join(__dirname, '../../../swarm-demo.ts'),
-                    path.join(__dirname, '../../swarm-demo.ts')
-                ];
-                let swarmDemoPath = null;
-                for (const p of possiblePaths){
-                    if (fs.existsSync(p)) {
-                        swarmDemoPath = p;
-                        break;
-                    }
-                }
-                if (swarmDemoPath && Deno) {
-                    // Run swarm-demo.ts directly with Deno
-                    const swarmArgs = [
-                        objective
-                    ];
-                    for (const [key, value] of Object.entries(flags || {})){
-                        swarmArgs.push(`--${key}`);
-                        if (value !== true) {
-                            swarmArgs.push(String(value));
-                        }
-                    }
-                    console.log('🚀 Starting advanced swarm execution...');
-                    const swarmProcess = spawn('node', [
-                        swarmDemoPath,
-                        ...swarmArgs
-                    ], {
-                        stdio: 'inherit'
-                    });
-                    swarmProcess.on('error', (err)=>{
-                        console.error('❌ Failed to launch swarm:', err.message);
-                    });
-                    swarmProcess.on('exit', (code)=>{
-                        if (code !== 0) {
-                            console.error(`❌ Swarm exited with code ${code}`);
-                        }
-                    });
-                    return;
-                }
-            } catch (e) {
-            // Fallback to basic message if can't run swarm-demo.ts
+          }
+
+          console.log('🚀 Starting advanced swarm execution...');
+          const swarmProcess = spawn('node', [swarmDemoPath, ...swarmArgs], {
+            stdio: 'inherit',
+          });
+
+          swarmProcess.on('error', (err) => {
+            console.error('❌ Failed to launch swarm:', err.message);
+          });
+
+          swarmProcess.on('exit', (code) => {
+            if (code !== 0) {
+              console.error(`❌ Swarm exited with code ${code}`);
             }
-            // Try to use Claude wrapper approach like SPARC does
-            try {
-                const { execSync } = await import("child_process");
-                // Check if claude command exists
-                try {
-                    execSync('which claude', {
-                        stdio: 'ignore'
-                    });
-                } catch (e) {
-                    // Claude not found, show fallback message
-                    console.log(`✅ Swarm initialized with ID: ${swarmId}`);
-                    console.log('\n⚠️  Note: Advanced swarm features require Claude or local installation.');
-                    console.log('Install Claude: https://claude.ai/code');
-                    console.log('Or install locally: npm install -g claude-flow@latest');
-                    console.log('\nThe swarm system would coordinate the following:');
-                    console.log('1. Agent spawning and task distribution');
-                    console.log('2. Parallel execution of subtasks');
-                    console.log('3. Memory sharing between agents');
-                    console.log('4. Progress monitoring and reporting');
-                    console.log('5. Result aggregation and quality checks');
-                    return;
-                }
-                // Claude is available, use it to run swarm
-                console.log('🚀 Launching swarm via Claude wrapper...');
-                if (flags.sparc !== false) {
-                    console.log('🧪 SPARC methodology enabled - using full TDD workflow');
-                }
-                // Build the prompt for Claude using SPARC methodology
-                const enableSparc = flags.sparc !== false;
-                const swarmPrompt = `Execute a swarm coordination task using ${enableSparc ? 'the full SPARC methodology' : 'standard approach'}:
+          });
+          return;
+        }
+      } catch (e) {
+        // Fallback to basic message if can't run swarm-demo.ts
+      }
+
+      // Try to use Claude wrapper approach like SPARC does
+      try {
+        const { execSync } = await import('child_process');
+
+        // Check if claude command exists
+        try {
+          execSync('which claude', { stdio: 'ignore' });
+        } catch (e) {
+          // Claude not found, show fallback message
+          console.log(`✅ Swarm initialized with ID: ${swarmId}`);
+          console.log('\n⚠️  Note: Advanced swarm features require Claude or local installation.');
+          console.log('Install Claude: https://claude.ai/code');
+          console.log('Or install locally: npm install -g claude-flow@latest');
+          console.log('\nThe swarm system would coordinate the following:');
+          console.log('1. Agent spawning and task distribution');
+          console.log('2. Parallel execution of subtasks');
+          console.log('3. Memory sharing between agents');
+          console.log('4. Progress monitoring and reporting');
+          console.log('5. Result aggregation and quality checks');
+          return;
+        }
+
+        // Claude is available, use it to run swarm
+        console.log('🚀 Launching swarm via Claude wrapper...');
+        if (flags.sparc !== false) {
+          console.log('🧪 SPARC methodology enabled - using full TDD workflow');
+        }
+
+        // Build the prompt for Claude using SPARC methodology
+        const enableSparc = flags.sparc !== false;
+        const swarmPrompt = `Execute a swarm coordination task using ${enableSparc ? 'the full SPARC methodology' : 'standard approach'}:
 
 OBJECTIVE: ${objective}
 
@@ -1240,7 +1377,9 @@ CONFIGURATION:
 - Quality Threshold: ${flags['quality-threshold'] || 0.8}
 ${enableSparc ? '- SPARC Enabled: YES - Use full Specification, Pseudocode, Architecture, Refinement (TDD), Completion methodology' : ''}
 
-${enableSparc ? `
+${
+  enableSparc
+    ? `
 SPARC METHODOLOGY REQUIREMENTS:
 
 1. SPECIFICATION PHASE:
@@ -1272,7 +1411,9 @@ SPARC METHODOLOGY REQUIREMENTS:
    - Create comprehensive documentation
    - Perform end-to-end testing
    - Validate against original requirements
-` : ''}
+`
+    : ''
+}
 
 EXECUTION APPROACH:
 1. Analyze the objective and break it down into specific tasks
@@ -1295,56 +1436,62 @@ IMPORTANT:
 - Make the code production-ready, not just examples
 
 Begin execution now. Create all necessary files and provide a complete, working solution.`;
-                // Execute Claude non-interactively by piping the prompt
-                const { spawn } = await import("child_process");
-                const claudeArgs = [];
-                // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
-                if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
-                    claudeArgs.push('--dangerously-skip-permissions');
-                }
-                // Spawn claude process
-                const claudeProcess = spawn('claude', claudeArgs, {
-                    stdio: [
-                        'pipe',
-                        'inherit',
-                        'inherit'
-                    ],
-                    shell: false
-                });
-                // Write the prompt to stdin and close it
-                claudeProcess.stdin.write(swarmPrompt);
-                claudeProcess.stdin.end();
-                // Wait for the process to complete
-                await new Promise((resolve, reject)=>{
-                    claudeProcess.on('close', (code)=>{
-                        if (code === 0) {
-                            resolve();
-                        } else {
-                            reject(new Error(`Claude process exited with code ${code}`));
-                        }
-                    });
-                    claudeProcess.on('error', (err)=>{
-                        reject(err);
-                    });
-                });
-            } catch (error) {
-                // Fallback if Claude execution fails
-                console.log(`✅ Swarm initialized with ID: ${swarmId}`);
-                console.log('\n⚠️  Note: Advanced swarm features require Claude or local installation.');
-                console.log('Install Claude: https://claude.ai/code');
-                console.log('Or install locally: npm install -g claude-flow@latest');
-                console.log('\nThe swarm system would coordinate the following:');
-                console.log('1. Agent spawning and task distribution');
-                console.log('2. Parallel execution of subtasks');
-                console.log('3. Memory sharing between agents');
-                console.log('4. Progress monitoring and reporting');
-                console.log('5. Result aggregation and quality checks');
-            }
-            return;
+
+        // Execute Claude non-interactively by piping the prompt
+        const { spawn } = await import('child_process');
+
+        const claudeArgs = [];
+
+        // Add auto-permission flag by default for swarm mode (unless explicitly disabled)
+        if (flags['dangerously-skip-permissions'] !== false && !flags['no-auto-permissions']) {
+          claudeArgs.push('--dangerously-skip-permissions');
         }
-        console.error('Swarm command error:', error);
-        // Fallback to comprehensive help if there's an import error
-        console.log(`
+
+        // Spawn claude process
+        const claudeProcess = spawn('claude', claudeArgs, {
+          stdio: ['pipe', 'inherit', 'inherit'],
+          shell: false,
+        });
+
+        // Write the prompt to stdin and close it
+        claudeProcess.stdin.write(swarmPrompt);
+        claudeProcess.stdin.end();
+
+        // Wait for the process to complete
+        await new Promise((resolve, reject) => {
+          claudeProcess.on('close', (code) => {
+            if (code === 0) {
+              resolve();
+            } else {
+              reject(new Error(`Claude process exited with code ${code}`));
+            }
+          });
+
+          claudeProcess.on('error', (err) => {
+            reject(err);
+          });
+        });
+      } catch (error) {
+        // Fallback if Claude execution fails
+        console.log(`✅ Swarm initialized with ID: ${swarmId}`);
+        console.log('\n⚠️  Note: Advanced swarm features require Claude or local installation.');
+        console.log('Install Claude: https://claude.ai/code');
+        console.log('Or install locally: npm install -g claude-flow@latest');
+        console.log('\nThe swarm system would coordinate the following:');
+        console.log('1. Agent spawning and task distribution');
+        console.log('2. Parallel execution of subtasks');
+        console.log('3. Memory sharing between agents');
+        console.log('4. Progress monitoring and reporting');
+        console.log('5. Result aggregation and quality checks');
+      }
+
+      return;
+    }
+
+    console.error('Swarm command error:', error);
+
+    // Fallback to comprehensive help if there's an import error
+    console.log(`
 🐝 Claude Flow Advanced Swarm System
 
 USAGE:
@@ -1421,40 +1568,48 @@ ADVANCED OPTIONS:
 For complete documentation and examples:
 https://github.com/ruvnet/claude-code-flow/docs/swarm.md
 `);
-    }
+  }
 }
+
 // Function to create swarm files directly
 async function createSwarmFiles(objective, flags) {
-    const fs = await import("fs");
-    const path = await import("path");
-    const swarmId = `swarm_${Math.random().toString(36).substring(2, 11)}_${Math.random().toString(36).substring(2, 11)}`;
-    console.log(`🐝 Swarm Execution Started: ${swarmId}`);
-    console.log(`📋 Objective: ${objective}`);
-    console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
-    // Extract target directory from objective
-    const targetMatch = objective.match(/in\s+([^\s]+)\/?$/i);
-    let targetDir = targetMatch ? targetMatch[1] : 'output';
-    // Resolve relative paths
-    if (!targetDir.startsWith('/')) {
-        targetDir = path.join(process.cwd(), targetDir);
-    }
-    console.log(`📁 Target directory: ${targetDir}`);
-    // Ensure target directory exists
-    await fs.promises.mkdir(targetDir, {
-        recursive: true
-    });
-    // Determine what to build based on objective
-    const isRestAPI = objective.toLowerCase().includes('rest api') || objective.toLowerCase().includes('api');
-    if (isRestAPI) {
-        // Create REST API
-        const apiDir = path.join(targetDir, 'rest-api');
-        await fs.promises.mkdir(apiDir, {
-            recursive: true
-        });
-        console.log(`\n🏗️  Creating REST API...`);
-        console.log(`  🤖 Agent developer-1: Creating server implementation`);
-        // Create server.js
-        const serverCode = `const express = require('express');
+  const fs = await import('fs');
+  const path = await import('path');
+
+  const swarmId = `swarm_${Math.random().toString(36).substring(2, 11)}_${Math.random().toString(36).substring(2, 11)}`;
+
+  console.log(`🐝 Swarm Execution Started: ${swarmId}`);
+  console.log(`📋 Objective: ${objective}`);
+  console.log(`🎯 Strategy: ${flags.strategy || 'auto'}`);
+
+  // Extract target directory from objective
+  const targetMatch = objective.match(/in\s+([^\s]+)\/?$/i);
+  let targetDir = targetMatch ? targetMatch[1] : 'output';
+
+  // Resolve relative paths
+  if (!targetDir.startsWith('/')) {
+    targetDir = path.join(process.cwd(), targetDir);
+  }
+
+  console.log(`📁 Target directory: ${targetDir}`);
+
+  // Ensure target directory exists
+  await fs.promises.mkdir(targetDir, { recursive: true });
+
+  // Determine what to build based on objective
+  const isRestAPI =
+    objective.toLowerCase().includes('rest api') || objective.toLowerCase().includes('api');
+
+  if (isRestAPI) {
+    // Create REST API
+    const apiDir = path.join(targetDir, 'rest-api');
+    await fs.promises.mkdir(apiDir, { recursive: true });
+
+    console.log(`\n🏗️  Creating REST API...`);
+    console.log(`  🤖 Agent developer-1: Creating server implementation`);
+
+    // Create server.js
+    const serverCode = `const express = require('express');
 const app = express();
 const port = process.env.PORT || 3000;
 
@@ -1509,45 +1664,47 @@ app.listen(port, () => {
 
 module.exports = app;
 `;
-        await fs.promises.writeFile(path.join(apiDir, 'server.js'), serverCode);
-        console.log(`  ✅ Created: server.js`);
-        // Create package.json
-        const packageJson = {
-            name: 'rest-api',
-            version: '1.0.0',
-            description: 'REST API created by Claude Flow Swarm',
-            main: 'server.js',
-            scripts: {
-                start: 'node server.js',
-                dev: 'nodemon server.js',
-                test: 'jest'
-            },
-            keywords: [
-                'rest',
-                'api',
-                'swarm',
-                'claude-flow'
-            ],
-            author: 'Claude Flow Swarm',
-            license: 'MIT',
-            dependencies: {
-                express: '^4.18.2'
-            },
-            devDependencies: {
-                nodemon: '^3.0.1',
-                jest: '^29.7.0',
-                supertest: '^6.3.3'
-            },
-            swarmMetadata: {
-                swarmId,
-                strategy: flags.strategy || 'development',
-                created: new Date().toISOString()
-            }
-        };
-        await fs.promises.writeFile(path.join(apiDir, 'package.json'), JSON.stringify(packageJson, null, 2));
-        console.log(`  ✅ Created: package.json`);
-        // Create README
-        const readme = `# REST API
+
+    await fs.promises.writeFile(path.join(apiDir, 'server.js'), serverCode);
+    console.log(`  ✅ Created: server.js`);
+
+    // Create package.json
+    const packageJson = {
+      name: 'rest-api',
+      version: '1.0.0',
+      description: 'REST API created by Claude Flow Swarm',
+      main: 'server.js',
+      scripts: {
+        start: 'node server.js',
+        dev: 'nodemon server.js',
+        test: 'jest',
+      },
+      keywords: ['rest', 'api', 'swarm', 'claude-flow'],
+      author: 'Claude Flow Swarm',
+      license: 'MIT',
+      dependencies: {
+        express: '^4.18.2',
+      },
+      devDependencies: {
+        nodemon: '^3.0.1',
+        jest: '^29.7.0',
+        supertest: '^6.3.3',
+      },
+      swarmMetadata: {
+        swarmId,
+        strategy: flags.strategy || 'development',
+        created: new Date().toISOString(),
+      },
+    };
+
+    await fs.promises.writeFile(
+      path.join(apiDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2),
+    );
+    console.log(`  ✅ Created: package.json`);
+
+    // Create README
+    const readme = `# REST API
 
 This REST API was created by the Claude Flow Swarm system.
 
@@ -1579,15 +1736,18 @@ npm start
 ---
 Created by Claude Flow Swarm
 `;
-        await fs.promises.writeFile(path.join(apiDir, 'README.md'), readme);
-        console.log(`  ✅ Created: README.md`);
-        console.log(`\n✅ Swarm completed successfully!`);
-        console.log(`📁 Files created in: ${apiDir}`);
-        console.log(`🆔 Swarm ID: ${swarmId}`);
-    } else {
-        // Create generic application
-        console.log(`\n🏗️  Creating application...`);
-        const appCode = `// Application created by Claude Flow Swarm
+
+    await fs.promises.writeFile(path.join(apiDir, 'README.md'), readme);
+    console.log(`  ✅ Created: README.md`);
+
+    console.log(`\n✅ Swarm completed successfully!`);
+    console.log(`📁 Files created in: ${apiDir}`);
+    console.log(`🆔 Swarm ID: ${swarmId}`);
+  } else {
+    // Create generic application
+    console.log(`\n🏗️  Creating application...`);
+
+    const appCode = `// Application created by Claude Flow Swarm
 // Objective: ${objective}
 // Swarm ID: ${swarmId}
 
@@ -1598,34 +1758,43 @@ function main() {
 
 main();
 `;
-        await fs.promises.writeFile(path.join(targetDir, 'app.js'), appCode);
-        console.log(`  ✅ Created: app.js`);
-        const packageJson = {
-            name: 'swarm-app',
-            version: '1.0.0',
-            description: `Application created by Claude Flow Swarm: ${objective}`,
-            main: 'app.js',
-            scripts: {
-                start: 'node app.js'
-            },
-            swarmMetadata: {
-                swarmId,
-                objective,
-                created: new Date().toISOString()
-            }
-        };
-        await fs.promises.writeFile(path.join(targetDir, 'package.json'), JSON.stringify(packageJson, null, 2));
-        console.log(`  ✅ Created: package.json`);
-        console.log(`\n✅ Swarm completed successfully!`);
-        console.log(`📁 Files created in: ${targetDir}`);
-        console.log(`🆔 Swarm ID: ${swarmId}`);
-    }
+
+    await fs.promises.writeFile(path.join(targetDir, 'app.js'), appCode);
+    console.log(`  ✅ Created: app.js`);
+
+    const packageJson = {
+      name: 'swarm-app',
+      version: '1.0.0',
+      description: `Application created by Claude Flow Swarm: ${objective}`,
+      main: 'app.js',
+      scripts: {
+        start: 'node app.js',
+      },
+      swarmMetadata: {
+        swarmId,
+        objective,
+        created: new Date().toISOString(),
+      },
+    };
+
+    await fs.promises.writeFile(
+      path.join(targetDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2),
+    );
+    console.log(`  ✅ Created: package.json`);
+
+    console.log(`\n✅ Swarm completed successfully!`);
+    console.log(`📁 Files created in: ${targetDir}`);
+    console.log(`🆔 Swarm ID: ${swarmId}`);
+  }
 }
+
 /**
  * Get strategy-specific guidance for swarm execution
- */ function getStrategyGuidance(strategy, objective) {
-    const guidanceMap = {
-        auto: `🤖 AUTO STRATEGY - INTELLIGENT TASK ANALYSIS:
+ */
+function getStrategyGuidance(strategy, objective) {
+  const guidanceMap = {
+    auto: `🤖 AUTO STRATEGY - INTELLIGENT TASK ANALYSIS:
 The swarm will analyze "${objective}" and automatically determine the best approach.
 
 ANALYSIS APPROACH:
@@ -1639,7 +1808,8 @@ MCP TOOL PATTERN:
 - Use task_create to build a hierarchical task structure
 - Spawn agents with agent_spawn based on detected requirements
 - Monitor with swarm_monitor and adjust strategy as needed`,
-        research: `🔬 RESEARCH STRATEGY - INFORMATION GATHERING & ANALYSIS:
+
+    research: `🔬 RESEARCH STRATEGY - INFORMATION GATHERING & ANALYSIS:
 Optimized for: "${objective}"
 
 RESEARCH PHASES:
@@ -1659,7 +1829,8 @@ MCP TOOL USAGE:
 - memory_search: Find related information across research
 - agent_communicate: Share discoveries between researchers
 - task_create: Break research into focused sub-investigations`,
-        development: `💻 DEVELOPMENT STRATEGY - SOFTWARE CREATION:
+
+    development: `💻 DEVELOPMENT STRATEGY - SOFTWARE CREATION:
 Building: "${objective}"
 
 DEVELOPMENT WORKFLOW:
@@ -1681,7 +1852,8 @@ MCP TOOL USAGE:
 - task_create: Create implementation tasks with dependencies
 - agent_assign: Assign specific components to developers
 - swarm_monitor: Track build progress and blockers`,
-        analysis: `📊 ANALYSIS STRATEGY - DATA EXAMINATION:
+
+    analysis: `📊 ANALYSIS STRATEGY - DATA EXAMINATION:
 Analyzing: "${objective}"
 
 ANALYSIS FRAMEWORK:
@@ -1703,7 +1875,8 @@ MCP TOOL USAGE:
 - memory_retrieve: Access historical analysis
 - task_create: Define analysis pipelines
 - agent_coordinate: Sync analysis phases`,
-        testing: `🧪 TESTING STRATEGY - QUALITY ASSURANCE:
+
+    testing: `🧪 TESTING STRATEGY - QUALITY ASSURANCE:
 Testing: "${objective}"
 
 TESTING PHASES:
@@ -1725,7 +1898,8 @@ MCP TOOL USAGE:
 - memory_store: Save test results and bug reports
 - agent_communicate: Report bugs to developers
 - swarm_monitor: Track testing coverage and progress`,
-        optimization: `⚡ OPTIMIZATION STRATEGY - PERFORMANCE IMPROVEMENT:
+
+    optimization: `⚡ OPTIMIZATION STRATEGY - PERFORMANCE IMPROVEMENT:
 Optimizing: "${objective}"
 
 OPTIMIZATION PROCESS:
@@ -1747,7 +1921,8 @@ MCP TOOL USAGE:
 - task_create: Create optimization tasks by priority
 - swarm_monitor: Track performance improvements
 - agent_communicate: Coordinate optimization efforts`,
-        maintenance: `🔧 MAINTENANCE STRATEGY - SYSTEM UPKEEP:
+
+    maintenance: `🔧 MAINTENANCE STRATEGY - SYSTEM UPKEEP:
 Maintaining: "${objective}"
 
 MAINTENANCE WORKFLOW:
@@ -1768,15 +1943,18 @@ MCP TOOL USAGE:
 - memory_retrieve: Access system history
 - task_create: Schedule maintenance tasks
 - agent_assign: Delegate specific updates
-- memory_store: Document all changes`
-    };
-    return guidanceMap[strategy] || guidanceMap['auto'];
+- memory_store: Document all changes`,
+  };
+
+  return guidanceMap[strategy] || guidanceMap['auto'];
 }
+
 /**
  * Get mode-specific guidance for coordination
- */ function getModeGuidance(mode) {
-    const modeMap = {
-        centralized: `🎯 CENTRALIZED MODE - SINGLE COORDINATOR:
+ */
+function getModeGuidance(mode) {
+  const modeMap = {
+    centralized: `🎯 CENTRALIZED MODE - SINGLE COORDINATOR:
 All decisions flow through one coordinator agent.
 
 COORDINATION PATTERN:
@@ -1796,7 +1974,8 @@ BEST FOR:
 - Small to medium projects
 - Well-defined objectives
 - Clear task dependencies`,
-        distributed: `🌐 DISTRIBUTED MODE - MULTIPLE COORDINATORS:
+
+    distributed: `🌐 DISTRIBUTED MODE - MULTIPLE COORDINATORS:
 Multiple coordinators share responsibility by domain.
 
 COORDINATION PATTERN:
@@ -1817,7 +1996,8 @@ BEST FOR:
 - Multiple workstreams
 - Complex systems
 - High availability needs`,
-        hierarchical: `🏗️ HIERARCHICAL MODE - TREE STRUCTURE:
+
+    hierarchical: `🏗️ HIERARCHICAL MODE - TREE STRUCTURE:
 Agents organized in management layers.
 
 COORDINATION PATTERN:
@@ -1838,7 +2018,8 @@ BEST FOR:
 - Multi-team efforts
 - Complex hierarchies
 - Phased deliveries`,
-        mesh: `🔗 MESH MODE - PEER-TO-PEER:
+
+    mesh: `🔗 MESH MODE - PEER-TO-PEER:
 Agents coordinate directly without central authority.
 
 COORDINATION PATTERN:
@@ -1859,7 +2040,8 @@ BEST FOR:
 - Exploratory work
 - Innovation tasks
 - Small expert teams`,
-        hybrid: `🎨 HYBRID MODE - MIXED STRATEGIES:
+
+    hybrid: `🎨 HYBRID MODE - MIXED STRATEGIES:
 Combine different coordination patterns as needed.
 
 COORDINATION PATTERN:
@@ -1878,15 +2060,18 @@ BEST FOR:
 - Complex projects
 - Uncertain requirements
 - Long-term efforts
-- Diverse objectives`
-    };
-    return modeMap[mode] || modeMap['centralized'];
+- Diverse objectives`,
+  };
+
+  return modeMap[mode] || modeMap['centralized'];
 }
+
 /**
  * Get agent recommendations based on strategy
- */ function getAgentRecommendations(strategy, maxAgents, objective) {
-    const recommendations = {
-        auto: `
+ */
+function getAgentRecommendations(strategy, maxAgents, objective) {
+  const recommendations = {
+    auto: `
 🤖 RECOMMENDED AGENT COMPOSITION (Auto-detected):
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -1905,7 +2090,8 @@ BEST FOR:
     {"id": "4", "content": "Spawn additional agents as needed", "status": "pending", "priority": "medium"}
   ]}
 \`\`\``,
-        research: `
+
+    research: `
 🔬 RECOMMENDED RESEARCH AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -1929,7 +2115,8 @@ BEST FOR:
     {"id": "5", "content": "Compile and synthesize insights", "status": "pending", "priority": "medium"}
   ]}
 \`\`\``,
-        development: `
+
+    development: `
 💻 RECOMMENDED DEVELOPMENT AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -1953,7 +2140,8 @@ BEST FOR:
     {"id": "5", "content": "Create comprehensive tests", "status": "pending", "priority": "medium"}
   ]}
 \`\`\``,
-        analysis: `
+
+    analysis: `
 📊 RECOMMENDED ANALYSIS AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -1977,7 +2165,8 @@ BEST FOR:
     {"id": "5", "content": "Generate business insights", "status": "pending", "priority": "medium"}
   ]}
 \`\`\``,
-        testing: `
+
+    testing: `
 🧪 RECOMMENDED TESTING AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -2001,7 +2190,8 @@ BEST FOR:
     {"id": "5", "content": "Execute security audit", "status": "pending", "priority": "high"}
   ]}
 \`\`\``,
-        optimization: `
+
+    optimization: `
 ⚡ RECOMMENDED OPTIMIZATION AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -2025,7 +2215,8 @@ BEST FOR:
     {"id": "5", "content": "Tune system parameters", "status": "pending", "priority": "medium"}
   ]}
 \`\`\``,
-        maintenance: `
+
+    maintenance: `
 🔧 RECOMMENDED MAINTENANCE AGENTS:
 ⚡ SPAWN ALL AGENTS IN ONE BATCH - Copy this entire block:
 
@@ -2048,35 +2239,39 @@ BEST FOR:
     {"id": "4", "content": "Run regression tests", "status": "pending", "priority": "high"},
     {"id": "5", "content": "Update documentation", "status": "pending", "priority": "medium"}
   ]}
-\`\`\``
-    };
-    return recommendations[strategy] || recommendations['auto'];
+\`\`\``,
+  };
+
+  return recommendations[strategy] || recommendations['auto'];
 }
+
 // Allow direct execution
 if (import.meta.main) {
-    // When called directly as a script, parse all arguments
-    const args = [];
-    const flags = {};
-    // Parse arguments and flags
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
-        if (arg.startsWith('--')) {
-            const flagName = arg.substring(2);
-            const nextArg = args[i + 1];
-            if (nextArg && !nextArg.startsWith('--')) {
-                flags[flagName] = nextArg;
-                i++; // Skip the next argument
-            } else {
-                flags[flagName] = true;
-            }
-        } else {
-            args.push(arg);
-        }
+  // When called directly as a script, parse all arguments
+  const args = [];
+  const flags = {};
+
+  // Parse arguments and flags
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const flagName = arg.substring(2);
+      const nextArg = args[i + 1];
+
+      if (nextArg && !nextArg.startsWith('--')) {
+        flags[flagName] = nextArg;
+        i++; // Skip the next argument
+      } else {
+        flags[flagName] = true;
+      }
+    } else {
+      args.push(arg);
     }
-    // The objective is all non-flag arguments joined
-    const objective = args.join(' ');
-    // Execute the swarm command
-    await swarmCommand([
-        objective
-    ], flags);
+  }
+
+  // The objective is all non-flag arguments joined
+  const objective = args.join(' ');
+
+  // Execute the swarm command
+  await swarmCommand([objective], flags);
 }