enhance_swarm 2.0.0 → 2.1.0

data/debug_spawn.rb

@@ -1,113 +0,0 @@
-#!/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

@@ -1,190 +0,0 @@
-#!/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

@@ -1,77 +0,0 @@
-#!/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

@@ -1,199 +0,0 @@
-#!/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/setup.sh

@@ -1,86 +0,0 @@
-#!/bin/bash
-set -e
-
-# EnhanceSwarm Auto-Setup Script
-# This script can be run directly from GitHub to set up EnhanceSwarm in any project
-
-echo "🚀 EnhanceSwarm Auto-Setup"
-echo "========================="
-
-# Colors
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Check dependencies
-echo -e "\n${YELLOW}Checking dependencies...${NC}"
-
-check_dependency() {
-    if command -v $1 &> /dev/null; then
-        echo -e "  ✅ $1 found"
-        return 0
-    else
-        echo -e "  ❌ $1 not found"
-        return 1
-    fi
-}
-
-MISSING_DEPS=0
-check_dependency "ruby" || MISSING_DEPS=1
-check_dependency "git" || MISSING_DEPS=1
-check_dependency "bundle" || MISSING_DEPS=1
-
-if [ $MISSING_DEPS -eq 1 ]; then
-    echo -e "\n${RED}Missing required dependencies. Please install them first.${NC}"
-    exit 1
-fi
-
-# Clone or update enhance_swarm
-ENHANCE_DIR="$HOME/.enhance_swarm"
-
-if [ -d "$ENHANCE_DIR" ]; then
-    echo -e "\n${YELLOW}Updating EnhanceSwarm...${NC}"
-    cd "$ENHANCE_DIR"
-    git pull origin main
-else
-    echo -e "\n${YELLOW}Installing EnhanceSwarm...${NC}"
-    git clone https://github.com/todddickerson/enhance_swarm.git "$ENHANCE_DIR"
-    cd "$ENHANCE_DIR"
-fi
-
-# Install gem dependencies
-echo -e "\n${YELLOW}Installing dependencies...${NC}"
-bundle install
-
-# Build and install the gem
-echo -e "\n${YELLOW}Building and installing gem...${NC}"
-rake build
-gem install pkg/enhance_swarm-*.gem
-
-# Check optional dependencies
-echo -e "\n${YELLOW}Checking optional dependencies...${NC}"
-check_dependency "claude" || echo "  ⚠️  Install Claude CLI for enhanced agent spawning"
-check_dependency "gemini" || echo "  ⚠️  Install Gemini CLI for large context analysis"
-
-# Initialize in current project if we're in a project directory
-if [ -f "Gemfile" ] || [ -f "package.json" ] || [ -f ".git/config" ]; then
-    echo -e "\n${YELLOW}Detected project directory. Initialize EnhanceSwarm here?${NC}"
-    read -p "Initialize EnhanceSwarm in current directory? (y/n) " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]]; then
-        enhance-swarm init
-    fi
-else
-    echo -e "\n${GREEN}✅ EnhanceSwarm installed successfully!${NC}"
-    echo -e "\nTo initialize in a project, run:"
-    echo -e "  ${YELLOW}cd your-project${NC}"
-    echo -e "  ${YELLOW}enhance-swarm init${NC}"
-fi
-
-echo -e "\n${GREEN}🎉 Setup complete!${NC}"
-echo -e "\nAvailable commands:"
-echo "  enhance-swarm init      - Initialize in a project"
-echo "  enhance-swarm enhance   - Run ENHANCE protocol"
-echo "  enhance-swarm doctor    - Check system setup"
-echo "  enhance-swarm --help    - See all commands"

data/test_blog_app/.enhance_swarm/archives/session_1751187575_e119ea73_20250629_105935.json

@@ -1,16 +0,0 @@
-{
-  "session_id": "1751187575_e119ea73",
-  "start_time": "2025-06-29T10:59:35+02:00",
-  "task_description": "Rails E2E test session",
-  "agents": [
-    {
-      "role": "test_agent",
-      "pid": 99999,
-      "worktree_path": "/test/path",
-      "task": "Test Rails development",
-      "start_time": "2025-06-29T10:59:35+02:00",
-      "status": "running"
-    }
-  ],
-  "status": "active"
-}