enhance_swarm 1.0.0 → 2.0.0

data/debug_spawn.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+# Debug script to test agent spawning
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'enhance_swarm'
+
+def test_agent_spawning
+  puts "🔍 Testing Agent Spawning Debug"
+  puts "=" * 50
+
+  begin
+    spawner = EnhanceSwarm::AgentSpawner.new
+    
+    # Test Claude CLI availability
+    puts "\n1️⃣  Testing Claude CLI..."
+    available = spawner.claude_cli_available?
+    puts "   📊 Claude CLI available: #{available}"
+    
+    if available
+      version = `claude --version 2>/dev/null`.strip
+      puts "   📊 Claude version: #{version}"
+    end
+    
+    # Test session manager
+    puts "\n2️⃣  Testing Session Manager..."
+    session_manager = EnhanceSwarm::SessionManager.new
+    session = session_manager.create_session("Debug test session")
+    puts "   📊 Session created: #{session[:session_id]}"
+    
+    # Test enhanced prompt building
+    puts "\n3️⃣  Testing Enhanced Prompt Building..."
+    prompt = spawner.send(:build_enhanced_agent_prompt, 
+                         "Test task for debugging", 
+                         "backend", 
+                         Dir.pwd)
+    puts "   📊 Prompt length: #{prompt.length} characters"
+    puts "   📊 Contains role: #{prompt.include?('BACKEND')}"
+    
+    # Test script creation
+    puts "\n4️⃣  Testing Agent Script Creation..."
+    script_path = spawner.send(:create_agent_script, 
+                              "Test prompt for script creation", 
+                              "backend", 
+                              Dir.pwd)
+    puts "   📊 Script created: #{File.exist?(script_path)}"
+    puts "   📊 Script executable: #{File.executable?(script_path)}"
+    
+    if File.exist?(script_path)
+      script_content = File.read(script_path)
+      puts "   📊 Script length: #{script_content.length} characters"
+      puts "   📊 Contains claude command: #{script_content.include?('claude')}"
+    end
+    
+    # Test the full spawn_agent method
+    puts "\n5️⃣  Testing Full Agent Spawn..."
+    puts "   🚀 Attempting to spawn agent..."
+    
+    result = spawner.spawn_agent(
+      role: "backend",
+      task: "Create a simple test file with hello world",
+      worktree: true
+    )
+    
+    if result
+      puts "   ✅ Agent spawned successfully!"
+      puts "   📊 PID: #{result[:pid]}"
+      puts "   📊 Role: #{result[:role]}"
+      puts "   📊 Worktree: #{result[:worktree_path]}"
+      
+      # Check if the process is actually running
+      begin
+        if result[:pid]
+          running = Process.getpgid(result[:pid])
+          puts "   📊 Process running: #{running ? 'Yes' : 'No'}"
+        end
+      rescue Errno::ESRCH
+        puts "   📊 Process running: No (not found)"
+      end
+      
+      # Wait a moment and check logs
+      sleep(3)
+      
+      # Check log files
+      puts "\n6️⃣  Checking Log Files..."
+      log_dir = '.enhance_swarm/logs'
+      if Dir.exist?(log_dir)
+        log_files = Dir.entries(log_dir).reject { |f| f.start_with?('.') }
+        log_files.each do |log_file|
+          log_path = File.join(log_dir, log_file)
+          content = File.read(log_path) rescue ""
+          puts "   📊 #{log_file}: #{content.length} characters"
+          if content.length > 0
+            puts "      Preview: #{content[0..100]}..."
+          end
+        end
+      end
+    else
+      puts "   ❌ Agent spawn failed"
+    end
+    
+  rescue => e
+    puts "   ❌ Error: #{e.class}: #{e.message}"
+    puts "   📊 Backtrace:"
+    e.backtrace.first(5).each { |line| puts "      #{line}" }
+  ensure
+    # Cleanup
+    session_manager&.cleanup_session
+  end
+end
+
+if __FILE__ == $0
+  test_agent_spawning
+end

data/debug_spawn_step_by_step.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# Debug spawn process step by step
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'enhance_swarm'
+
+def debug_spawn_process
+  puts "🔧 Debugging Spawn Process Step by Step"
+  puts "=" * 50
+
+  begin
+    ENV['ENHANCE_SWARM_DEBUG'] = 'true'
+    
+    # Step 1: Test AgentSpawner initialization
+    puts "\n1️⃣  Initializing AgentSpawner..."
+    spawner = EnhanceSwarm::AgentSpawner.new
+    puts "   ✅ AgentSpawner initialized"
+    
+    # Step 2: Test Claude CLI availability
+    puts "\n2️⃣  Testing Claude CLI..."
+    claude_available = spawner.claude_cli_available?
+    puts "   📊 Claude CLI available: #{claude_available}"
+    
+    if claude_available
+      claude_version = `claude --version 2>/dev/null`.strip
+      puts "   📊 Claude version: #{claude_version}"
+    end
+    
+    # Step 3: Test worktree creation
+    puts "\n3️⃣  Testing Worktree Creation..."
+    role = "frontend"
+    
+    # Call the private method using send
+    worktree_path = spawner.send(:create_agent_worktree, role)
+    puts "   📊 Worktree created: #{worktree_path}"
+    
+    if worktree_path
+      puts "   📊 Worktree exists: #{Dir.exist?(worktree_path)}"
+      puts "   📊 Worktree files: #{Dir.entries(worktree_path).reject { |f| f.start_with?('.') }}"
+    end
+    
+    # Step 4: Test prompt building
+    puts "\n4️⃣  Testing Prompt Building..."
+    task = "Create a simple test component"
+    prompt = spawner.send(:build_agent_prompt, task, role, worktree_path)
+    puts "   📊 Prompt length: #{prompt.length} characters"
+    puts "   📊 First 100 chars: #{prompt[0..100]}..."
+    
+    # Step 5: Test script creation
+    puts "\n5️⃣  Testing Script Creation..."
+    script_path = spawner.send(:create_agent_script, prompt, role, worktree_path || Dir.pwd)
+    puts "   📊 Script created: #{script_path}"
+    puts "   📊 Script exists: #{File.exist?(script_path)}"
+    puts "   📊 Script executable: #{File.executable?(script_path)}"
+    
+    if File.exist?(script_path)
+      script_content = File.read(script_path)
+      puts "   📊 Script length: #{script_content.length} characters"
+      puts "   📊 First few lines:"
+      script_content.lines.first(5).each_with_index do |line, i|
+        puts "      #{i+1}: #{line.strip}"
+      end
+    end
+    
+    # Step 6: Test environment building
+    puts "\n6️⃣  Testing Environment..."
+    env = spawner.send(:build_agent_environment, role, worktree_path)
+    puts "   📊 Environment variables set:"
+    env.select { |k, v| k.start_with?('ENHANCE_SWARM') }.each do |k, v|
+      puts "      #{k}=#{v}"
+    end
+    
+    # Step 7: Try manual script execution
+    puts "\n7️⃣  Testing Manual Script Execution..."
+    if File.exist?(script_path)
+      puts "   🚀 Attempting to run script manually..."
+      
+      # Change to the working directory
+      original_dir = Dir.pwd
+      working_dir = worktree_path || Dir.pwd
+      
+      begin
+        Dir.chdir(working_dir)
+        puts "   📊 Changed to directory: #{Dir.pwd}"
+        
+        # Try to execute the script with timeout
+        require 'timeout'
+        
+        output = ""
+        error = ""
+        
+        begin
+          Timeout::timeout(10) do
+            output = `bash #{script_path} 2>&1`
+          end
+          exit_status = $?.exitstatus
+          
+          puts "   📊 Script exit status: #{exit_status}"
+          puts "   📊 Output length: #{output.length}"
+          puts "   📊 Output preview: #{output[0..300]}..." if output.length > 0
+          
+        rescue Timeout::Error
+          puts "   ⚠️  Script execution timed out (>10s)"
+        end
+        
+      ensure
+        Dir.chdir(original_dir)
+      end
+    end
+    
+    # Step 8: Test Process.spawn approach
+    puts "\n8️⃣  Testing Process.spawn..."
+    if File.exist?(script_path)
+      working_dir = worktree_path || Dir.pwd
+      log_dir = '.enhance_swarm/logs'
+      
+      puts "   🚀 Spawning process..."
+      puts "   📊 Working dir: #{working_dir}"
+      puts "   📊 Log dir: #{log_dir}"
+      
+      begin
+        FileUtils.mkdir_p(log_dir)
+        
+        pid = Process.spawn(
+          '/bin/bash', script_path,
+          chdir: working_dir,
+          out: File.join(log_dir, 'debug_manual_output.log'),
+          err: File.join(log_dir, 'debug_manual_error.log')
+        )
+        
+        puts "   📊 Process spawned: PID #{pid}"
+        Process.detach(pid)
+        
+        # Wait a moment and check status
+        sleep(3)
+        
+        begin
+          Process.getpgid(pid)
+          puts "   📊 Process still running"
+        rescue Errno::ESRCH
+          puts "   📊 Process completed"
+        end
+        
+        # Check output files
+        output_file = File.join(log_dir, 'debug_manual_output.log')
+        error_file = File.join(log_dir, 'debug_manual_error.log')
+        
+        if File.exist?(output_file)
+          output = File.read(output_file)
+          puts "   📊 Manual output: #{output.length} chars"
+          puts "   📊 Output preview: #{output[0..200]}..." if output.length > 0
+        end
+        
+        if File.exist?(error_file)
+          error = File.read(error_file)
+          puts "   📊 Manual error: #{error.length} chars"
+          puts "   📊 Error preview: #{error[0..200]}..." if error.length > 0
+        end
+        
+      rescue => e
+        puts "   ❌ Process spawn failed: #{e.message}"
+      end
+    end
+    
+    # Cleanup
+    puts "\n9️⃣  Cleanup..."
+    if worktree_path && Dir.exist?(worktree_path)
+      puts "   🧹 Cleaning up worktree..."
+      begin
+        system("git worktree remove #{worktree_path}")
+        branch_name = File.basename(worktree_path)
+        system("git branch -d #{branch_name}")
+        puts "   ✅ Worktree cleaned up"
+      rescue => e
+        puts "   ⚠️  Cleanup warning: #{e.message}"
+      end
+    end
+    
+  rescue => e
+    puts "   ❌ Error: #{e.class}: #{e.message}"
+    puts "   📊 Backtrace:"
+    e.backtrace.first(10).each { |line| puts "      #{line}" }
+  ensure
+    ENV.delete('ENHANCE_SWARM_DEBUG')
+  end
+end
+
+if __FILE__ == $0
+  debug_spawn_process
+end

data/debug_worktree.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+# Debug script to test worktree creation
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'enhance_swarm'
+
+def test_worktree_creation
+  puts "🔍 Testing Git Worktree Creation Debug"
+  puts "=" * 50
+
+  spawner = EnhanceSwarm::AgentSpawner.new
+  
+  # Test the private create_agent_worktree method
+  begin
+    puts "\n1️⃣  Testing worktree creation..."
+    
+    # Check current git status
+    git_status = `git status --porcelain 2>&1`
+    puts "   📊 Git status: #{git_status.strip}"
+    
+    # Check if we're in a git repository
+    in_git_repo = system('git rev-parse --git-dir > /dev/null 2>&1')
+    puts "   📊 In git repo: #{in_git_repo}"
+    
+    # Check current branch
+    current_branch = `git branch --show-current 2>&1`.strip
+    puts "   📊 Current branch: #{current_branch}"
+    
+    # Check if we have commits
+    has_commits = system('git log --oneline -1 > /dev/null 2>&1')
+    puts "   📊 Has commits: #{has_commits}"
+    
+    # Test directory creation
+    worktree_dir = '.enhance_swarm/worktrees'
+    puts "   📊 Creating directory: #{worktree_dir}"
+    FileUtils.mkdir_p(worktree_dir) unless Dir.exist?(worktree_dir)
+    puts "   📊 Directory exists: #{Dir.exist?(worktree_dir)}"
+    
+    # Try to call the create_agent_worktree method
+    puts "\n2️⃣  Calling create_agent_worktree..."
+    worktree_path = spawner.send(:create_agent_worktree, 'debug_test')
+    
+    if worktree_path
+      puts "   ✅ Success! Worktree created at: #{worktree_path}"
+      puts "   📊 Directory exists: #{Dir.exist?(worktree_path)}"
+      
+      # List contents
+      if Dir.exist?(worktree_path)
+        contents = Dir.entries(worktree_path).reject { |f| f.start_with?('.') }
+        puts "   📊 Contents: #{contents.join(', ')}"
+      end
+    else
+      puts "   ❌ Failed to create worktree"
+    end
+    
+  rescue => e
+    puts "   ❌ Error: #{e.class}: #{e.message}"
+    puts "   📊 Backtrace: #{e.backtrace.first(3).join(', ')}"
+  end
+  
+  puts "\n3️⃣  Checking existing worktrees..."
+  existing_worktrees = `git worktree list 2>&1`
+  puts "   📊 Existing worktrees:"
+  existing_worktrees.each_line { |line| puts "      #{line.strip}" }
+  
+  puts "\n4️⃣  Testing CommandExecutor directly..."
+  begin
+    result = EnhanceSwarm::CommandExecutor.execute('git', 'worktree', 'list')
+    puts "   ✅ CommandExecutor works: #{result}"
+  rescue => e
+    puts "   ❌ CommandExecutor error: #{e.message}"
+  end
+end
+
+if __FILE__ == $0
+  test_worktree_creation
+end

data/final_validation_test.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+# Final comprehensive validation test for EnhanceSwarm v1.0
+
+$LOAD_PATH.unshift File.expand_path('lib', __dir__)
+require 'enhance_swarm'
+
+def run_final_validation
+  puts "🔍 EnhanceSwarm v1.0 Final Validation Test"
+  puts "=" * 60
+
+  results = {
+    core_functionality: {},
+    reliability: {},
+    user_experience: {},
+    production_readiness: {}
+  }
+
+  begin
+    # 1. Core Functionality Tests
+    puts "\n1️⃣  CORE FUNCTIONALITY VALIDATION"
+    puts "-" * 40
+
+    # Test AgentSpawner
+    puts "   Testing AgentSpawner..."
+    spawner = EnhanceSwarm::AgentSpawner.new
+    claude_available = spawner.claude_cli_available?
+    results[:core_functionality][:claude_cli] = claude_available
+    puts "   📊 Claude CLI: #{claude_available ? '✅' : '❌'}"
+
+    # Test SessionManager
+    puts "   Testing SessionManager..."
+    session_manager = EnhanceSwarm::SessionManager.new
+    session = session_manager.create_session("Validation test")
+    session_works = session && session[:session_id]
+    results[:core_functionality][:session_management] = session_works
+    puts "   📊 Session Management: #{session_works ? '✅' : '❌'}"
+
+    # Test Configuration
+    puts "   Testing Configuration..."
+    config = EnhanceSwarm.configuration
+    config_works = config && config.project_name
+    results[:core_functionality][:configuration] = config_works
+    puts "   📊 Configuration: #{config_works ? '✅' : '❌'}"
+
+    # Test Orchestrator
+    puts "   Testing Orchestrator..."
+    orchestrator = EnhanceSwarm::Orchestrator.new
+    orchestrator_works = orchestrator.respond_to?(:spawn_single)
+    results[:core_functionality][:orchestrator] = orchestrator_works
+    puts "   📊 Orchestrator: #{orchestrator_works ? '✅' : '❌'}"
+
+    # 2. Reliability Tests
+    puts "\n2️⃣  RELIABILITY VALIDATION"
+    puts "-" * 40
+
+    # Test Error Handling
+    puts "   Testing Error Handling..."
+    begin
+      # Test with invalid input
+      spawner.spawn_agent(role: nil, task: nil, worktree: false)
+      error_handling = false
+    rescue => e
+      error_handling = true
+      puts "   📊 Error properly caught: #{e.class}"
+    end
+    results[:reliability][:error_handling] = error_handling
+    puts "   📊 Error Handling: #{error_handling ? '✅' : '❌'}"
+
+    # Test Logger
+    puts "   Testing Logger..."
+    logger_works = EnhanceSwarm::Logger.respond_to?(:info)
+    results[:reliability][:logging] = logger_works
+    puts "   📊 Logging System: #{logger_works ? '✅' : '❌'}"
+
+    # Test Cleanup
+    puts "   Testing Cleanup..."
+    cleanup_works = EnhanceSwarm::CleanupManager.respond_to?(:cleanup_stale_worktrees)
+    results[:reliability][:cleanup] = cleanup_works
+    puts "   📊 Cleanup Manager: #{cleanup_works ? '✅' : '❌'}"
+
+    # 3. User Experience Tests
+    puts "\n3️⃣  USER EXPERIENCE VALIDATION"
+    puts "-" * 40
+
+    # Test CLI Components
+    puts "   Testing CLI Components..."
+    cli_works = EnhanceSwarm::CLI.respond_to?(:new)
+    results[:user_experience][:cli] = cli_works
+    puts "   📊 CLI Interface: #{cli_works ? '✅' : '❌'}"
+
+    # Test Dashboard
+    puts "   Testing Dashboard..."
+    dashboard_works = EnhanceSwarm::VisualDashboard.respond_to?(:instance)
+    results[:user_experience][:dashboard] = dashboard_works
+    puts "   📊 Visual Dashboard: #{dashboard_works ? '✅' : '❌'}"
+
+    # Test Smart Defaults
+    puts "   Testing Smart Defaults..."
+    smart_defaults_works = EnhanceSwarm::SmartDefaults.respond_to?(:suggest_role_for_task)
+    results[:user_experience][:smart_defaults] = smart_defaults_works
+    puts "   📊 Smart Defaults: #{smart_defaults_works ? '✅' : '❌'}"
+
+    # 4. Production Readiness Tests
+    puts "\n4️⃣  PRODUCTION READINESS VALIDATION"
+    puts "-" * 40
+
+    # Test actual spawn (non-blocking)
+    puts "   Testing Real Agent Spawn..."
+    spawn_result = spawner.spawn_agent(
+      role: "general",
+      task: "Quick validation test - just echo 'validation successful'",
+      worktree: false
+    )
+    spawn_works = spawn_result && spawn_result[:pid]
+    results[:production_readiness][:real_spawn] = spawn_works
+    puts "   📊 Real Agent Spawn: #{spawn_works ? '✅' : '❌'}"
+    
+    if spawn_works
+      puts "   📊 Spawned PID: #{spawn_result[:pid]}"
+      
+      # Brief wait to check process
+      sleep(2)
+      begin
+        Process.getpgid(spawn_result[:pid])
+        puts "   📊 Process Status: Running ✅"
+      rescue Errno::ESRCH
+        puts "   📊 Process Status: Completed ✅"
+      end
+    end
+
+    # Test Dependencies
+    puts "   Testing Dependencies..."
+    deps_works = EnhanceSwarm::DependencyValidator.respond_to?(:validate_all)
+    results[:production_readiness][:dependencies] = deps_works
+    puts "   📊 Dependency Validation: #{deps_works ? '✅' : '❌'}"
+
+    # Test Process Monitoring
+    puts "   Testing Process Monitoring..."
+    monitor_works = EnhanceSwarm::ProcessMonitor.respond_to?(:new)
+    results[:production_readiness][:monitoring] = monitor_works
+    puts "   📊 Process Monitoring: #{monitor_works ? '✅' : '❌'}"
+
+    # 5. Calculate Final Score
+    puts "\n5️⃣  FINAL SCORING"
+    puts "-" * 40
+
+    total_tests = 0
+    passed_tests = 0
+
+    results.each do |category, tests|
+      category_passed = tests.values.count(true)
+      category_total = tests.count
+      total_tests += category_total
+      passed_tests += category_passed
+      
+      percentage = category_total > 0 ? (category_passed.to_f / category_total * 100).round(1) : 0
+      puts "   #{category.to_s.gsub('_', ' ').capitalize}: #{category_passed}/#{category_total} (#{percentage}%)"
+    end
+
+    overall_percentage = total_tests > 0 ? (passed_tests.to_f / total_tests * 100).round(1) : 0
+    
+    puts "\n" + "=" * 60
+    puts "🎯 FINAL VALIDATION RESULTS"
+    puts "=" * 60
+    puts "Total Tests: #{total_tests}"
+    puts "Tests Passed: #{passed_tests}"
+    puts "Success Rate: #{overall_percentage}%"
+    
+    if overall_percentage >= 95
+      puts "\n🚀 PRODUCTION READY - EXCELLENT"
+      puts "   All critical systems operational"
+    elsif overall_percentage >= 85
+      puts "\n✅ PRODUCTION READY - GOOD"
+      puts "   Minor issues, but deployable"
+    elsif overall_percentage >= 70
+      puts "\n⚠️  PRODUCTION READY - WITH CAVEATS"
+      puts "   Some issues need attention"
+    else
+      puts "\n❌ NOT PRODUCTION READY"
+      puts "   Significant issues require resolution"
+    end
+
+    return overall_percentage
+
+  rescue => e
+    puts "   ❌ Validation Error: #{e.class}: #{e.message}"
+    puts "   📊 Backtrace:"
+    e.backtrace.first(3).each { |line| puts "      #{line}" }
+    return 0
+  ensure
+    # Cleanup
+    session_manager&.cleanup_session
+  end
+end
+
+if __FILE__ == $0
+  score = run_final_validation
+  puts "\n🎖️  EnhanceSwarm v1.0 Production Score: #{score}/100"
+end

data/lib/enhance_swarm/agent_spawner.rb

@@ -286,6 +286,8 @@ module EnhanceSwarm
         'You specialize in user experience design, interaction flows, accessibility, and user-centric improvements.'
       when 'general'
         'You are a general-purpose agent capable of handling various development tasks across the full stack.'
+      when 'scaffolding'
+        'You specialize in Bullet Train Super Scaffolding, following Andrew Culver\'s conventions for team-scoped architecture, model relationships, and framework configuration.'
       else
         "You are a #{role} specialist agent focusing on your area of expertise."
       end
@@ -417,6 +419,8 @@ module EnhanceSwarm
         base_prompt += "\n\nFOCUS: Controllers, views, JavaScript, forms, user interactions, and integration."
       when 'qa'
         base_prompt += "\n\nFOCUS: Comprehensive testing, edge cases, quality assurance, and validation."
+      when 'scaffolding'
+        base_prompt += "\n\nFOCUS: Bullet Train Super Scaffolding, Andrew Culver's best practices, team-scoped architecture, and framework setup."
       end
 
       base_prompt
@@ -449,7 +453,7 @@ module EnhanceSwarm
 
     def sanitize_role(role)
       # Only allow known safe roles
-      allowed_roles = %w[ux backend frontend qa general]
+      allowed_roles = %w[ux backend frontend qa general scaffolding]
       role = role.to_s.downcase.strip
       allowed_roles.include?(role) ? role : 'general'
     end

data/lib/enhance_swarm/cli.rb

@@ -4,6 +4,8 @@ require 'thor'
 require 'colorize'
 require_relative 'web_ui'
 require_relative 'session_manager'
+require_relative 'task_coordinator'
+require_relative 'smart_orchestration'
 
 module EnhanceSwarm
   class CLI < Thor
@@ -54,15 +56,46 @@ module EnhanceSwarm
         notifications: options[:notifications]
       })
 
-      if options[:control_agent] && !options[:dry_run]
-        enhance_with_control_agent
-      else
-        orchestrator = Orchestrator.new
-        orchestrator.enhance(
-          task_id: options[:task],
-          dry_run: options[:dry_run],
-          follow: options[:follow]
-        )
+      # Get task description from user
+      print "Enter task description: "
+      task_description = $stdin.gets.chomp
+      
+      # Use smart orchestration by default
+      begin
+        SmartOrchestration.enhance_with_coordination(task_description)
+        say "✅ Smart orchestration completed successfully!", :green
+      rescue StandardError => e
+        say "❌ Smart orchestration failed, falling back to control agent", :yellow
+        Logger.error("Smart orchestration error: #{e.message}")
+        
+        if options[:control_agent] && !options[:dry_run]
+          enhance_with_control_agent_manual(task_description)
+        else
+          orchestrator = Orchestrator.new
+          orchestrator.enhance(
+            task_id: options[:task],
+            dry_run: options[:dry_run],
+            follow: options[:follow]
+          )
+        end
+      end
+    end
+
+    desc 'orchestrate TASK_DESC', 'Intelligent multi-agent orchestration with smart coordination'
+    option :coordination, type: :boolean, default: true, desc: 'Enable intelligent task coordination'
+    option :follow, type: :boolean, default: false, desc: 'Stream live output from all agents'
+    def orchestrate(task_desc)
+      say "🎯 Starting intelligent multi-agent orchestration", :blue
+      say "Task: #{task_desc}", :white
+      
+      begin
+        coordinator = TaskCoordinator.new
+        coordinator.coordinate_task(task_desc)
+        
+        say "✅ Multi-agent orchestration completed successfully!", :green
+      rescue StandardError => e
+        say "❌ Orchestration failed: #{e.message}", :red
+        say "Debug info: #{e.backtrace.first(3).join("\n")}", :yellow
       end
     end