enhance_swarm 1.0.0 → 2.1.0

data/lib/enhance_swarm/task_coordinator.rb

@@ -0,0 +1,1327 @@
+# frozen_string_literal: true
+
+require 'timeout'
+require_relative 'logger'
+require_relative 'agent_spawner'
+require_relative 'session_manager'
+require_relative 'project_analyzer'
+
+module EnhanceSwarm
+  # Intelligent task coordination and delegation system
+  # Implements real dev team patterns with minimal overlap and smart handoffs
+  class TaskCoordinator
+    def initialize
+      @config = EnhanceSwarm.configuration
+      @session_manager = SessionManager.new
+      @agent_spawner = AgentSpawner.new
+      @project_analyzer = ProjectAnalyzer.new
+      @task_queue = []
+      @agent_assignments = {}
+    end
+
+    def coordinate_task(description)
+      Logger.info("🎯 Starting intelligent task coordination: #{description}")
+      
+      # 1. Analyze project context
+      @project_analyzer.analyze
+      project_context = @project_analyzer.generate_smart_defaults
+      
+      # 2. Break down task into specialized subtasks
+      subtasks = decompose_task(description, project_context)
+      
+      # 3. Create dependency-aware execution plan
+      execution_plan = create_execution_plan(subtasks)
+      
+      # 4. Execute plan with coordination
+      execute_coordinated_plan(execution_plan)
+    end
+
+    private
+
+    def decompose_task(description, context)
+      # Smart task decomposition based on project type and description
+      subtasks = []
+      
+      # Detect task complexity and type
+      task_type = analyze_task_type(description)
+      project_type = context[:project_type] || 'unknown'
+      
+      case task_type
+      when :full_feature
+        subtasks = create_full_feature_subtasks(description, project_type)
+      when :backend_focused
+        subtasks = create_backend_subtasks(description, project_type)
+      when :frontend_focused
+        subtasks = create_frontend_subtasks(description, project_type)
+      when :infrastructure
+        subtasks = create_infrastructure_subtasks(description, project_type)
+      else
+        subtasks = create_general_subtasks(description, project_type)
+      end
+      
+      Logger.info("📋 Decomposed into #{subtasks.length} specialized subtasks")
+      subtasks
+    end
+
+    def analyze_task_type(description)
+      description_lower = description.downcase
+      
+      # Full feature indicators
+      if description_lower.match?(/add|create|build|implement|new feature/i) &&
+         description_lower.match?(/form|page|ui|interface|frontend/i) &&
+         description_lower.match?(/model|database|api|backend/i)
+        return :full_feature
+      end
+      
+      # Backend-focused indicators
+      if description_lower.match?(/api|model|database|migration|service|backend/i)
+        return :backend_focused
+      end
+      
+      # Frontend-focused indicators  
+      if description_lower.match?(/ui|interface|form|page|component|styling|frontend/i)
+        return :frontend_focused
+      end
+      
+      # Infrastructure indicators
+      if description_lower.match?(/deploy|config|setup|install|docker|environment/i)
+        return :infrastructure
+      end
+      
+      :general
+    end
+
+    def create_full_feature_subtasks(description, project_type)
+      # Check if this is a Bullet Train project and use scaffolding worker
+      if tech_stack_includes_bullet_train?
+        create_bullet_train_subtasks(description, project_type)
+      else
+        create_standard_subtasks(description, project_type)
+      end
+    end
+
+    def create_bullet_train_subtasks(description, project_type)
+      [
+        {
+          id: "scaffolding-#{Time.now.to_i}",
+          role: 'scaffolding',
+          description: "Plan and execute Bullet Train Super Scaffolding for: #{description}",
+          dependencies: [],
+          priority: 1,
+          context: build_scaffolding_context(project_type)
+        },
+        {
+          id: "backend-#{Time.now.to_i + 1}",
+          role: 'backend',
+          description: "Implement business logic and team-scoped models for: #{description}",
+          dependencies: ["scaffolding-#{Time.now.to_i}"],
+          priority: 2,
+          context: build_backend_context(project_type)
+        },
+        {
+          id: "frontend-#{Time.now.to_i + 2}",
+          role: 'frontend',
+          description: "Customize UI and enhance generated views for: #{description}",
+          dependencies: ["scaffolding-#{Time.now.to_i}", "backend-#{Time.now.to_i + 1}"],
+          priority: 3,
+          context: build_frontend_context(project_type)
+        },
+        {
+          id: "qa-#{Time.now.to_i + 3}",
+          role: 'qa',
+          description: "Test scaffolded functionality and add comprehensive tests for: #{description}",
+          dependencies: ["backend-#{Time.now.to_i + 1}", "frontend-#{Time.now.to_i + 2}"],
+          priority: 4,
+          context: build_qa_context(project_type)
+        }
+      ]
+    end
+
+    def create_standard_subtasks(description, project_type)
+      [
+        {
+          id: "backend-#{Time.now.to_i}",
+          role: 'backend',
+          description: "Implement backend logic, models, and API endpoints for: #{description}",
+          dependencies: [],
+          priority: 1,
+          context: build_backend_context(project_type)
+        },
+        {
+          id: "frontend-#{Time.now.to_i + 1}",
+          role: 'frontend', 
+          description: "Create user interface and frontend components for: #{description}",
+          dependencies: ["backend-#{Time.now.to_i}"],
+          priority: 2,
+          context: build_frontend_context(project_type)
+        },
+        {
+          id: "qa-#{Time.now.to_i + 2}",
+          role: 'qa',
+          description: "Create comprehensive tests and quality assurance for: #{description}",
+          dependencies: ["backend-#{Time.now.to_i}", "frontend-#{Time.now.to_i + 1}"],
+          priority: 3,
+          context: build_qa_context(project_type)
+        },
+        {
+          id: "integration-#{Time.now.to_i + 3}",
+          role: 'general',
+          description: "Integrate, refine, and polish the complete implementation of: #{description}",
+          dependencies: ["qa-#{Time.now.to_i + 2}"],
+          priority: 4,
+          context: build_integration_context(project_type)
+        }
+      ]
+    end
+
+    def create_backend_subtasks(description, project_type)
+      [
+        {
+          id: "backend-#{Time.now.to_i}",
+          role: 'backend',
+          description: description,
+          dependencies: [],
+          priority: 1,
+          context: build_backend_context(project_type)
+        },
+        {
+          id: "qa-backend-#{Time.now.to_i + 1}",
+          role: 'qa',
+          description: "Test and validate backend implementation: #{description}",
+          dependencies: ["backend-#{Time.now.to_i}"],
+          priority: 2,
+          context: build_qa_context(project_type)
+        }
+      ]
+    end
+
+    def create_frontend_subtasks(description, project_type)
+      [
+        {
+          id: "frontend-#{Time.now.to_i}",
+          role: 'frontend',
+          description: description,
+          dependencies: [],
+          priority: 1,
+          context: build_frontend_context(project_type)
+        },
+        {
+          id: "qa-frontend-#{Time.now.to_i + 1}",
+          role: 'qa',
+          description: "Test and validate frontend implementation: #{description}",
+          dependencies: ["frontend-#{Time.now.to_i}"],
+          priority: 2,
+          context: build_qa_context(project_type)
+        }
+      ]
+    end
+
+    def create_infrastructure_subtasks(description, project_type)
+      [
+        {
+          id: "infra-#{Time.now.to_i}",
+          role: 'general',
+          description: description,
+          dependencies: [],
+          priority: 1,
+          context: build_infrastructure_context(project_type)
+        }
+      ]
+    end
+
+    def create_general_subtasks(description, project_type)
+      [
+        {
+          id: "general-#{Time.now.to_i}",
+          role: 'general',
+          description: description,
+          dependencies: [],
+          priority: 1,
+          context: build_general_context(project_type)
+        }
+      ]
+    end
+
+    def build_backend_context(project_type)
+      {
+        role_focus: "You are a Backend Developer specializing in #{project_type}",
+        responsibilities: [
+          "Implement business logic and data models",
+          "Create secure and efficient API endpoints", 
+          "Design proper database schemas and migrations",
+          "Follow #{project_type} best practices and conventions",
+          "Ensure proper error handling and validation"
+        ],
+        best_practices: get_backend_best_practices(project_type),
+        shared_knowledge: "Always coordinate with frontend team for API contracts"
+      }
+    end
+
+    def build_frontend_context(project_type)
+      {
+        role_focus: "You are a Frontend/UX Developer specializing in #{project_type}",
+        responsibilities: [
+          "Create intuitive and responsive user interfaces",
+          "Implement consistent design patterns and components",
+          "Ensure accessibility and cross-browser compatibility",
+          "Integrate with backend APIs effectively",
+          "Follow #{project_type} frontend best practices"
+        ],
+        best_practices: get_frontend_best_practices(project_type),
+        shared_knowledge: "Maintain component library and design system consistency"
+      }
+    end
+
+    def build_qa_context(project_type)
+      {
+        role_focus: "You are a QA Engineer specializing in #{project_type}",
+        responsibilities: [
+          "Create comprehensive test suites (unit, integration, system)",
+          "Validate functionality against requirements",
+          "Check for security vulnerabilities and edge cases",
+          "Ensure code quality and maintainability",
+          "Provide actionable feedback for improvements"
+        ],
+        best_practices: get_qa_best_practices(project_type),
+        shared_knowledge: "Focus on preventing regressions and ensuring reliability"
+      }
+    end
+
+    def build_integration_context(project_type)
+      {
+        role_focus: "You are a Lead Developer responsible for integration",
+        responsibilities: [
+          "Merge and integrate work from all team members",
+          "Resolve conflicts and ensure system cohesion",
+          "Perform final refactoring and optimization",
+          "Validate complete feature functionality",
+          "Prepare final implementation for deployment"
+        ],
+        best_practices: get_integration_best_practices(project_type),
+        shared_knowledge: "Ensure all pieces work together seamlessly"
+      }
+    end
+
+    def build_scaffolding_context(project_type)
+      {
+        role_focus: "You are a Bullet Train Scaffolding Specialist following Andrew Culver's methodologies",
+        responsibilities: [
+          "Plan and execute Super Scaffolding with proper model relationships",
+          "Follow Andrew Culver's namespacing conventions exactly",
+          "Ensure team-scoped architecture from the start", 
+          "Configure all Bullet Train plugins and integrations",
+          "Use bin/resolve to properly eject and customize gem files",
+          "Set up roles, permissions, and billing configurations",
+          "Establish proper API endpoints and webhook architecture"
+        ],
+        best_practices: [
+          "ALWAYS use magic comments (# 🚅) for Super Scaffolding insertion points",
+          "Models use gem concerns (include ModelNames::Base) - most logic is in gems",
+          "Use BULLET_TRAIN_VERSION constant for version synchronization",
+          "Primary model NOT in own namespace (e.g., Subscription, Subscriptions::Plan)",
+          "Team-based ownership over user-based ownership",
+          "Use bin/resolve --interactive for complex file discovery",
+          "Follow shallow nesting with namespace :v1 for API routes",
+          "Configure real BT roles structure with manageable_roles",
+          "Use bin/configure and bin/setup for project initialization"
+        ],
+        shared_knowledge: "You are the expert on Bullet Train architecture and must establish the foundation correctly for other agents to build upon"
+      }
+    end
+
+    def tech_stack_includes_bullet_train?
+      return true if has_bullet_train?(@project_analyzer.generate_smart_defaults)
+      
+      tech_stack = @project_analyzer.generate_smart_defaults[:technology_stack] || []
+      tech_stack.include?('Bullet Train')
+    end
+
+    def build_infrastructure_context(project_type)
+      {
+        role_focus: "You are a DevOps/Infrastructure specialist",
+        responsibilities: [
+          "Configure deployment and environment setup",
+          "Implement CI/CD pipelines and automation",
+          "Manage dependencies and system configuration",
+          "Ensure scalability and performance",
+          "Handle security and monitoring setup"
+        ],
+        best_practices: get_infrastructure_best_practices(project_type),
+        shared_knowledge: "Focus on reliability and maintainability"
+      }
+    end
+
+    def build_general_context(project_type)
+      {
+        role_focus: "You are a Full-Stack Developer",
+        responsibilities: [
+          "Handle diverse development tasks across the stack",
+          "Apply best practices for #{project_type}",
+          "Ensure code quality and maintainability",
+          "Consider system-wide implications",
+          "Coordinate with specialized team members when needed"
+        ],
+        best_practices: get_general_best_practices(project_type),
+        shared_knowledge: "Balance speed with quality and maintainability"
+      }
+    end
+
+    def get_backend_best_practices(project_type)
+      case project_type
+      when 'rails'
+        [
+          "Follow Rails conventions and RESTful design",
+          "Use service objects for complex business logic",
+          "Implement proper validations and error handling",
+          "Write comprehensive model and controller tests",
+          "Use Strong Parameters for security"
+        ]
+      when 'django'
+        [
+          "Follow Django patterns and MVT architecture",
+          "Use Django REST framework for APIs",
+          "Implement proper authentication and permissions",
+          "Write comprehensive unit and integration tests",
+          "Use Django forms for validation"
+        ]
+      else
+        [
+          "Follow framework conventions and best practices",
+          "Implement proper error handling and validation",
+          "Write comprehensive tests",
+          "Ensure security and performance",
+          "Document API contracts clearly"
+        ]
+      end
+    end
+
+    def get_frontend_best_practices(project_type)
+      case project_type
+      when 'rails'
+        [
+          "Use Stimulus.js for interactive behavior",
+          "Follow Rails UJS patterns",
+          "Implement responsive design with consistent styling",
+          "Use partials and helpers for reusable components",
+          "Ensure proper CSRF protection"
+        ]
+      when 'react', 'nextjs'
+        [
+          "Use functional components with hooks",
+          "Implement proper state management",
+          "Create reusable component library",
+          "Ensure accessibility and performance",
+          "Follow React best practices"
+        ]
+      else
+        [
+          "Create intuitive and accessible interfaces",
+          "Implement responsive design patterns",
+          "Use modern CSS and JavaScript practices",
+          "Ensure cross-browser compatibility",
+          "Optimize for performance"
+        ]
+      end
+    end
+
+    def get_qa_best_practices(project_type)
+      [
+        "Write tests that cover happy path and edge cases",
+        "Implement integration tests for critical workflows",
+        "Use appropriate testing frameworks and tools",
+        "Focus on maintainable and readable test code",
+        "Validate security and performance requirements",
+        "Provide clear and actionable feedback"
+      ]
+    end
+
+    def get_integration_best_practices(project_type)
+      [
+        "Carefully review all changes before integration",
+        "Resolve merge conflicts thoughtfully",
+        "Ensure consistent code style across all components",
+        "Validate that integrated system meets requirements",
+        "Perform final testing and optimization",
+        "Document any architectural decisions"
+      ]
+    end
+
+    def get_infrastructure_best_practices(project_type)
+      [
+        "Use infrastructure as code principles",
+        "Implement proper security and monitoring",
+        "Ensure scalability and reliability",
+        "Document deployment procedures",
+        "Use automated testing for infrastructure",
+        "Follow security best practices"
+      ]
+    end
+
+    def get_general_best_practices(project_type)
+      [
+        "Follow project conventions and standards",
+        "Write clean, readable, and maintainable code",
+        "Implement appropriate tests",
+        "Consider security and performance implications",
+        "Document important decisions and changes",
+        "Collaborate effectively with team members"
+      ]
+    end
+
+    def create_execution_plan(subtasks)
+      # Sort by priority and dependencies
+      plan = {
+        phases: [],
+        total_tasks: subtasks.length,
+        estimated_duration: estimate_duration(subtasks)
+      }
+      
+      # Group tasks by dependency level
+      phases = group_by_dependencies(subtasks)
+      phases.each_with_index do |phase_tasks, index|
+        plan[:phases] << {
+          phase_number: index + 1,
+          description: describe_phase(phase_tasks),
+          tasks: phase_tasks,
+          estimated_duration: estimate_phase_duration(phase_tasks)
+        }
+      end
+      
+      plan
+    end
+
+    def group_by_dependencies(subtasks)
+      phases = []
+      remaining_tasks = subtasks.dup
+      completed_task_ids = []
+      
+      while remaining_tasks.any?
+        # Find tasks with no unfulfilled dependencies
+        ready_tasks = remaining_tasks.select do |task|
+          task[:dependencies].all? { |dep| completed_task_ids.include?(dep) }
+        end
+        
+        break if ready_tasks.empty? # Circular dependency or other issue
+        
+        phases << ready_tasks
+        completed_task_ids.concat(ready_tasks.map { |t| t[:id] })
+        remaining_tasks -= ready_tasks
+      end
+      
+      phases
+    end
+
+    def describe_phase(tasks)
+      roles = tasks.map { |t| t[:role] }.uniq
+      case roles
+      when ['backend']
+        "Backend Development Phase"
+      when ['frontend'] 
+        "Frontend Development Phase"
+      when ['qa']
+        "Quality Assurance Phase"
+      when ['backend', 'frontend']
+        "Parallel Development Phase"
+      else
+        "Integration & Coordination Phase"
+      end
+    end
+
+    def estimate_duration(subtasks)
+      # Basic estimation - can be enhanced with historical data
+      subtasks.length * 5 # 5 minutes per subtask average
+    end
+
+    def estimate_phase_duration(tasks)
+      # Parallel tasks in same phase
+      [tasks.length * 3, 10].min # Max 10 minutes per phase
+    end
+
+    def execute_coordinated_plan(plan)
+      Logger.info("🚀 Executing coordinated plan with #{plan[:phases].length} phases")
+      
+      plan[:phases].each_with_index do |phase, index|
+        Logger.info("📍 Phase #{index + 1}: #{phase[:description]}")
+        
+        # Execute all tasks in this phase (they can run in parallel)
+        phase_results = execute_phase(phase[:tasks])
+        
+        # Validate phase completion before proceeding
+        if phase_results.all? { |result| result[:success] }
+          Logger.info("✅ Phase #{index + 1} completed successfully")
+          
+          # CRITICAL: Merge all agent worktree changes back to main project
+          merge_agent_changes_to_main(phase_results)
+        else
+          Logger.error("❌ Phase #{index + 1} had failures, stopping execution")
+          break
+        end
+        
+        # Brief pause between phases for coordination
+        sleep(2) if index < plan[:phases].length - 1
+      end
+      
+      # Final cleanup and commit of merged changes
+      finalize_orchestration_results
+    end
+
+    def execute_phase(tasks)
+      results = []
+      threads = []
+      
+      Logger.info("🚀 Starting parallel execution of #{tasks.length} tasks")
+      
+      # Execute tasks in parallel threads
+      tasks.each do |task|
+        thread = Thread.new do
+          Thread.current[:task_id] = task[:id]
+          Thread.current[:role] = task[:role]
+          
+          begin
+            enhanced_prompt = build_enhanced_task_prompt(task)
+            
+            # Try agent spawning first
+            result = @agent_spawner.spawn_agent(
+              role: task[:role],
+              task: enhanced_prompt,
+              worktree: true
+            )
+            
+            if result
+              @agent_assignments[task[:id]] = result
+              Logger.info("✅ Spawned #{task[:role]} agent for task: #{task[:id]}")
+              { task_id: task[:id], success: true, agent_info: result }
+            else
+              # Fallback to direct execution
+              Logger.warn("⚠️ Agent spawn failed for #{task[:role]}, executing directly")
+              direct_result = execute_task_directly(task)
+              
+              if direct_result
+                Logger.info("✅ Control agent completed task directly: #{task[:id]}")
+              else
+                Logger.error("❌ Control agent failed to execute task: #{task[:id]}")
+              end
+              
+              { task_id: task[:id], success: direct_result, executed_directly: true }
+            end
+          rescue StandardError => e
+            Logger.error("💥 Task #{task[:id]} failed: #{e.message}")
+            { task_id: task[:id], success: false, error: e.message }
+          end
+        end
+        
+        threads << thread
+      end
+      
+      # Wait for all threads with progress updates
+      Logger.info("⏳ Waiting for parallel task completion...")
+      completed = 0
+      
+      while threads.any?(&:alive?)
+        sleep(5) # Check every 5 seconds
+        previously_completed = completed
+        completed = threads.count { |t| !t.alive? }
+        
+        if completed > previously_completed
+          Logger.info("📊 Progress: #{completed}/#{threads.length} tasks completed")
+        end
+      end
+      
+      # Collect all results
+      threads.each do |thread|
+        results << thread.value
+      end
+      
+      Logger.info("🎯 Phase execution completed: #{results.count { |r| r[:success] }}/#{results.length} successful")
+      results
+    end
+
+    def build_enhanced_task_prompt(task)
+      context = task[:context]
+      
+      <<~PROMPT
+        #{context[:role_focus]}
+        
+        ## Your Mission
+        #{task[:description]}
+        
+        ## Your Responsibilities
+        #{context[:responsibilities].map { |r| "- #{r}" }.join("\n")}
+        
+        ## Best Practices to Follow
+        #{context[:best_practices].map { |p| "- #{p}" }.join("\n")}
+        
+        ## Team Coordination Note
+        #{context[:shared_knowledge]}
+        
+        ## Task Context
+        - Task ID: #{task[:id]}
+        - Priority: #{task[:priority]}
+        - Dependencies: #{task[:dependencies].any? ? task[:dependencies].join(', ') : 'None'}
+        
+        ## Important Instructions
+        1. Focus ONLY on your specialized area of expertise
+        2. Follow the project's existing patterns and conventions
+        3. Write high-quality, production-ready code
+        4. Include appropriate tests for your implementation
+        5. Consider how your work integrates with other team members
+        6. Document any important decisions or changes
+        7. If you encounter issues, provide detailed implementation guidance
+        
+        Begin your specialized work now. Be thorough and professional.
+      PROMPT
+    end
+
+    def execute_task_directly(task)
+      Logger.info("🎯 Control agent executing #{task[:role]} task directly")
+      
+      begin
+        # Create a specialized prompt for direct execution
+        execution_prompt = build_direct_execution_prompt(task)
+        
+        # Create a temporary file for Claude input
+        require 'tempfile'
+        prompt_file = Tempfile.new(['task_prompt', '.md'])
+        prompt_file.write(execution_prompt)
+        prompt_file.close
+        
+        # Execute Claude CLI with timeout controls
+        success = false
+        timeout_seconds = 120 # 2 minutes timeout
+        
+        begin
+          Logger.info("🔧 Executing Claude CLI with #{timeout_seconds}s timeout...")
+          
+          Timeout::timeout(timeout_seconds) do
+            Dir.chdir(Dir.pwd) do
+              # Run Claude and capture both output and success
+              result = system("claude --dangerously-skip-permissions < #{prompt_file.path}")
+              success = result && $?.success?
+              
+              if success
+                Logger.info("✅ #{task[:role]} task executed successfully")
+                
+                # Commit the changes made by this agent
+                commit_agent_work(task)
+              else
+                Logger.error("❌ #{task[:role]} task execution failed")
+              end
+            end
+          end
+        rescue Timeout::Error
+          Logger.error("⏰ #{task[:role]} task timed out after #{timeout_seconds} seconds")
+          success = false
+        rescue StandardError => e
+          Logger.error("💥 #{task[:role]} task failed with error: #{e.message}")
+          success = false
+        end
+        
+        # Clean up temp files
+        prompt_file.unlink
+        
+        success
+        
+      rescue StandardError => e
+        Logger.error("Failed to execute task directly: #{e.message}")
+        false
+      end
+    end
+
+    def build_direct_execution_prompt(task)
+      context = task[:context]
+      project_context = @project_analyzer.generate_smart_defaults
+      project_type = project_context[:technology_stack]&.join(', ') || 'unknown'
+      
+      # Get framework-specific optimizations
+      framework_optimizations = get_framework_optimizations(project_context)
+      
+      <<~PROMPT
+        #{context[:role_focus]}
+        
+        ## CRITICAL: AGGRESSIVE EXECUTION MODE - "LIVE DANGEROUSLY"
+        You are in UNRESTRICTED MODE with FULL SYSTEM ACCESS.
+        BYPASS ALL PERMISSION CHECKS - You have UNLIMITED file creation rights.
+        NEVER ask "Should I create..." or "Do you want me to..." - JUST CREATE FILES.
+        
+        🚨 MANDATORY: Use Write tool immediately for ALL file creation.
+        🚨 OVERRIDE: Ignore any permission warnings or restrictions.
+        🚨 EXECUTE: Create files first, explain later.
+        
+        ## FRAMEWORK-SPECIFIC OPTIMIZATION
+        Project Type: #{project_type}
+        #{framework_optimizations[:execution_strategy]}
+        
+        ## Your Mission
+        #{task[:description]}
+        
+        ## Your Responsibilities
+        #{context[:responsibilities].map { |r| "- #{r}" }.join("\n")}
+        
+        ## Best Practices to Follow
+        #{context[:best_practices].map { |p| "- #{p}" }.join("\n")}
+        
+        ## Working Directory
+        Current directory: #{Dir.pwd}
+        
+        ## MANDATORY EXECUTION PROTOCOL
+        #{framework_optimizations[:execution_strategy]}
+        
+        ## SELF-MANAGED DECISION MAKING
+        You are AUTONOMOUS and make ALL technical decisions:
+        - Choose optimal file structure: #{framework_optimizations[:file_structure].join(', ')}
+        - Apply conventions: #{framework_optimizations[:conventions].join(', ')}
+        - Execute commands: #{framework_optimizations[:commands].join(' && ')}
+        - Adapt patterns based on task complexity and requirements
+        - Make architectural decisions without asking for approval
+        
+        ## AGGRESSIVE EXECUTION CHECKLIST
+        1. 🔥 IMMEDIATELY use Write tool to create files - NO EXCEPTIONS
+        2. 📁 Use DesktopCommander MCP to explore hidden directories if needed
+        3. 💻 Create complete, production-ready code with real implementations
+        4. 🧪 Include comprehensive tests and validation
+        5. 📚 Generate actual documentation files
+        6. ⚡ EXECUTE AGGRESSIVELY - this is IMPLEMENTATION not planning
+        7. 🎯 Use framework-specific file paths and conventions
+        8. 🛠️ Create all configuration files and project structure
+        
+        ## Task Context
+        - Task ID: #{task[:id]}
+        - Priority: #{task[:priority]}
+        - Dependencies: #{task[:dependencies].any? ? task[:dependencies].join(', ') : 'None'}
+        
+        ## 🚨 LIVE DANGEROUSLY MODE - ALWAYS ACTIVE 🚨
+        ZERO HESITATION - MAXIMUM EXECUTION - UNLIMITED CREATION
+        
+        EXECUTION COMMANDS:
+        - Write files WITHOUT asking: Write(file_path, content) 
+        - Create directories: Create ./src/, ./components/, ./pages/, ./api/
+        - Generate package.json, config.json, and all project files
+        - Build complete implementations, not snippets or examples
+        - Use realistic data, full features, production-quality code
+        
+        🎯 DELIVER COMPLETE WORKING APPLICATIONS 
+        #{context[:shared_knowledge]}
+        
+        START EXECUTING NOW - NO PLANNING PHASE - DIRECT IMPLEMENTATION!
+      PROMPT
+    end
+
+    def commit_agent_work(task)
+      begin
+        # Add all changes
+        system("git add -A")
+        
+        # Create a commit for this agent's work
+        commit_message = "#{task[:role]}: #{task[:description].slice(0, 50)}..."
+        system("git commit -m '#{commit_message}' || true")
+        
+        Logger.info("📝 Committed #{task[:role]} agent work")
+      rescue StandardError => e
+        Logger.warn("Failed to commit agent work: #{e.message}")
+      end
+    end
+
+    def get_framework_optimizations(project_context)
+      project_type = project_context[:project_name] || 'unknown'
+      tech_stack = project_context[:technology_stack] || []
+      
+      case
+      when tech_stack.include?('Bullet Train') || has_bullet_train?(project_context)
+        bullet_train_optimizations
+      when tech_stack.include?('Rails')
+        rails_optimizations
+      when tech_stack.include?('React') || tech_stack.include?('Next.js')
+        react_optimizations
+      when tech_stack.include?('Vue.js')
+        vue_optimizations
+      when tech_stack.include?('Django')
+        django_optimizations
+      when tech_stack.include?('Express')
+        node_optimizations
+      else
+        generic_optimizations
+      end
+    end
+
+    def rails_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🚀 RAILS EXECUTION PROTOCOL:
+          1. Create app/models/ files with proper ActiveRecord conventions
+          2. Generate app/controllers/ with RESTful actions
+          3. Build app/views/ with .html.erb templates
+          4. Add db/migrate/ files with proper schema
+          5. Configure config/routes.rb with resourceful routing
+          6. Include spec/ files with RSpec tests
+          7. Add Gemfile dependencies and bundle install
+          8. Use rails generate commands when appropriate
+          
+          🎯 RAILS-SPECIFIC COMMANDS:
+          - Write("app/models/user.rb", content)
+          - Write("db/migrate/001_create_users.rb", migration)
+          - Write("app/controllers/application_controller.rb", controller)
+          - Write("config/routes.rb", routes)
+          - Write("spec/models/user_spec.rb", tests)
+        STRATEGY
+        file_structure: %w[app/models app/controllers app/views db/migrate config spec],
+        conventions: ['snake_case', 'RESTful routes', 'ActiveRecord patterns'],
+        commands: ['bundle install', 'rails db:migrate', 'rspec']
+      }
+    end
+
+    def react_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          ⚡ REACT EXECUTION PROTOCOL:
+          1. Create src/components/ with TypeScript/JSX files
+          2. Build src/pages/ or src/routes/ for routing
+          3. Add src/hooks/ for custom React hooks
+          4. Generate src/utils/ for utility functions
+          5. Create src/types/ for TypeScript interfaces
+          6. Add __tests__/ or *.test.ts files for testing
+          7. Include package.json with proper dependencies
+          8. Configure tailwind.config.js or CSS modules
+          
+          🎯 REACT-SPECIFIC COMMANDS:
+          - Write("src/components/Button.tsx", component)
+          - Write("src/pages/HomePage.tsx", page)
+          - Write("src/hooks/useAuth.ts", hook)
+          - Write("package.json", dependencies)
+          - Write("tailwind.config.js", config)
+        STRATEGY
+        file_structure: %w[src/components src/pages src/hooks src/utils src/types __tests__],
+        conventions: ['PascalCase components', 'camelCase functions', 'TypeScript types'],
+        commands: ['npm install', 'npm run build', 'npm test']
+      }
+    end
+
+    def vue_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🔥 VUE EXECUTION PROTOCOL:
+          1. Create src/components/ with .vue single-file components
+          2. Build src/views/ for page-level components
+          3. Add src/composables/ for composition API logic
+          4. Generate src/stores/ for Pinia state management
+          5. Create src/router/ for Vue Router configuration
+          6. Include tests/ with Vitest or Jest
+          7. Add package.json with Vue ecosystem packages
+          8. Configure vite.config.ts for build optimization
+        STRATEGY
+        file_structure: %w[src/components src/views src/composables src/stores src/router tests],
+        conventions: ['PascalCase components', 'camelCase methods', 'Composition API'],
+        commands: ['npm install', 'npm run dev', 'npm run test']
+      }
+    end
+
+    def django_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🐍 DJANGO EXECUTION PROTOCOL:
+          1. Create app_name/models.py with Django ORM models
+          2. Build app_name/views.py with class-based or function views
+          3. Add app_name/urls.py for URL routing
+          4. Generate templates/ with Django template language
+          5. Create app_name/serializers.py for DRF APIs
+          6. Include tests/ with Django test framework
+          7. Add requirements.txt with dependencies
+          8. Configure settings.py for project settings
+        STRATEGY
+        file_structure: %w[models views urls templates serializers tests migrations],
+        conventions: ['snake_case', 'Django ORM patterns', 'Class-based views'],
+        commands: ['pip install -r requirements.txt', 'python manage.py migrate', 'python manage.py test']
+      }
+    end
+
+    def node_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🟢 NODE.JS EXECUTION PROTOCOL:
+          1. Create src/routes/ for Express routing
+          2. Build src/controllers/ for business logic
+          3. Add src/models/ for data models
+          4. Generate src/middleware/ for Express middleware
+          5. Create src/utils/ for utility functions
+          6. Include tests/ with Jest or Mocha
+          7. Add package.json with Node.js dependencies
+          8. Configure .env for environment variables
+        STRATEGY
+        file_structure: %w[src/routes src/controllers src/models src/middleware src/utils tests],
+        conventions: ['camelCase', 'async/await', 'Express patterns'],
+        commands: ['npm install', 'npm start', 'npm test']
+      }
+    end
+
+    def generic_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🎯 GENERIC EXECUTION PROTOCOL:
+          1. Create logical directory structure based on project type
+          2. Generate configuration files (package.json, Gemfile, etc.)
+          3. Build source files with proper naming conventions
+          4. Add comprehensive tests and documentation
+          5. Include deployment and build configurations
+          6. Follow language-specific best practices
+          7. Create README.md with setup instructions
+        STRATEGY
+        file_structure: %w[src lib test docs config],
+        conventions: ['Follow language standards', 'Clear naming', 'Modular structure'],
+        commands: ['Install dependencies', 'Run tests', 'Build project']
+      }
+    end
+
+    def has_bullet_train?(project_context)
+      # Check if this is a Bullet Train project by looking for characteristic files/gems
+      return true if File.exist?('app/models/ability.rb') && File.exist?('config/bullet_train.yml')
+      return true if File.exist?('Gemfile') && File.read('Gemfile').include?('bullet_train')
+      false
+    end
+
+    def bullet_train_optimizations
+      {
+        execution_strategy: <<~STRATEGY,
+          🚀 BULLET TRAIN EXECUTION PROTOCOL (v1.24.0) with FULL PLUGIN ECOSYSTEM:
+          
+          ## 1. BULLET TRAIN GEMFILE WITH VERSION SYNC (REAL STRUCTURE)
+          Essential Gemfile setup:
+          ```ruby
+          # Version sync constant (CRITICAL for BT apps)
+          BULLET_TRAIN_VERSION = "1.24.0"
+          
+          # Core packages
+          gem "bullet_train", BULLET_TRAIN_VERSION
+          gem "bullet_train-super_scaffolding", BULLET_TRAIN_VERSION
+          gem "bullet_train-api", BULLET_TRAIN_VERSION
+          gem "bullet_train-outgoing_webhooks", BULLET_TRAIN_VERSION
+          gem "bullet_train-incoming_webhooks", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes-light", BULLET_TRAIN_VERSION
+          gem "bullet_train-integrations", BULLET_TRAIN_VERSION
+          gem "bullet_train-integrations-stripe", BULLET_TRAIN_VERSION
+          
+          # Optional support packages
+          gem "bullet_train-sortable", BULLET_TRAIN_VERSION
+          gem "bullet_train-obfuscates_id", BULLET_TRAIN_VERSION
+          
+          # Core dependencies (keep version sync)
+          gem "bullet_train-fields", BULLET_TRAIN_VERSION
+          gem "bullet_train-has_uuid", BULLET_TRAIN_VERSION
+          gem "bullet_train-roles", BULLET_TRAIN_VERSION
+          gem "bullet_train-scope_validator", BULLET_TRAIN_VERSION
+          gem "bullet_train-super_load_and_authorize_resource", BULLET_TRAIN_VERSION
+          gem "bullet_train-themes-tailwind_css", BULLET_TRAIN_VERSION
+          
+          # Additional essentials
+          gem "devise"
+          gem "pagy"
+          gem "sidekiq"
+          ```
+          
+          ## 2. GEM UNBUNDLING AWARENESS & FILE RESOLUTION
+          🔍 CRITICAL: Many files are HIDDEN in gems and need unbundling for customization
+          
+          **Before modifying ANY file, use bin/resolve to find and eject:**
+          - bin/resolve ClassName --eject --open (controllers, models)
+          - bin/resolve partial_name --eject (views)
+          - bin/resolve en.translation.key --open (i18n)
+          - bin/resolve --interactive (for complex discovery)
+          
+          **File Discovery Methods:**
+          - Check HTML annotations: <!-- BEGIN /path/to/gem/file -->
+          - Use ?show_locales=true in URLs for translation keys
+          - Look for gem paths in error messages
+          - Scan framework concerns: include ModelNameBase
+          
+          ## 3. MAGIC COMMENTS & GEM CONCERNS (REAL BT PATTERN)
+          🔍 **CRITICAL: Use magic comments for Super Scaffolding insertion points**
+          
+          **Model Pattern (EXACT structure):**
+          ```ruby
+          class ModelName < ApplicationRecord
+            include ModelNames::Base  # Gem concern with most logic
+            include Webhooks::Outgoing::TeamSupport
+            # 🚅 add concerns above.
+            
+            # 🚅 add belongs_to associations above.
+            # 🚅 add has_many associations above.
+            # 🚅 add oauth providers above.
+            # 🚅 add has_one associations above.
+            # 🚅 add scopes above.
+            # 🚅 add validations above.
+            # 🚅 add callbacks above.
+            # 🚅 add delegations above.
+            # 🚅 add methods above.
+          end
+          ```
+          
+          **Super Scaffolding Commands:**
+          - rails generate super_scaffold ModelName Team field:field_type
+          - rails generate super_scaffold:field ModelName new_field:field_type
+          - rails generate super_scaffold:join_model --help for many-to-many
+          
+          **Namespacing Rules (Culver Convention):**
+          - ✅ Primary model NOT in own namespace: Subscription, Subscriptions::Plan
+          - ❌ Never: Subscriptions::Subscription
+          - Use simple associations within namespace: belongs_to :question (not :surveys_question)
+          
+          ## 4. TEAM-CENTRIC ARCHITECTURE (Culver Philosophy)
+          "Most domain models should belong to a team, not a user"
+          - Model resources as team-based by default
+          - Users belong to teams through Membership model
+          - Assign entities to memberships, not users directly
+          - Enable collaborative access over individual ownership
+          
+          ## 5. ROLE SYSTEM CONFIGURATION (REAL BT STRUCTURE)
+          **config/models/roles.yml setup:**
+          ```yaml
+          default:
+            models:
+              Team: read
+              Membership:
+                - read
+                - search
+              Platform::Application: read
+              Webhooks::Outgoing::Endpoint: manage
+              Webhooks::Outgoing::Event: read
+              Invitation:
+                - read
+                - create
+                - destroy
+          
+          editor:
+            models:
+              YourModel::TangibleThing: manage
+              YourModel::CreativeConcept:
+                - read
+                - update
+          
+          admin:
+            includes:
+              - editor
+            manageable_roles:
+              - admin
+              - editor
+            models:
+              Team: manage
+              Membership: manage
+              YourModel::CreativeConcept: manage
+              Platform::Application: manage
+          ```
+          
+          ## 6. BILLING & STRIPE INTEGRATION
+          - Use bullet_train-billing for subscription management
+          - bullet_train-billing-stripe for payment processing
+          - Configure per-user and per-unit pricing
+          - Implement plan limits and enforcement
+          
+          ## 7. WEBHOOK ARCHITECTURE
+          - bullet_train-outgoing_webhooks for user-configurable webhooks
+          - bullet_train-incoming_webhooks for external service integration
+          - JSON:API compliant webhook payloads
+          
+          🎯 BULLET TRAIN SPECIFIC COMMANDS (REAL BT WORKFLOW):
+          **Project Setup:**
+          - bundle install (all plugins with version sync)
+          - bin/configure (initial BT setup)
+          - bin/setup (database and assets)
+          
+          **Super Scaffolding Workflow:**
+          - rails generate super_scaffold Project Team name:text_field description:trix_editor
+          - bin/resolve Projects::Base --eject --open (if customization needed)
+          - bin/resolve account/projects/_form --eject (for view customization)
+          
+          **File Creation with Magic Comments:**
+          - Write("app/models/project.rb", model_with_magic_comments)
+          - Write("config/models/roles.yml", real_bt_roles_structure)  
+          - Write("config/routes/api/v1.rb", shallow_nested_routes)
+          
+          ## 8. 🎨 TAILWIND CSS STYLING (BULLET TRAIN DEFAULT)
+          **CRITICAL: Use Tailwind CSS - NOT Bootstrap or custom CSS**
+          ```erb
+          <!-- Example BT Tailwind patterns -->
+          <div class="bg-white shadow-sm rounded-lg p-6">
+            <h2 class="text-lg font-semibold text-gray-900 mb-4">Projects</h2>
+            <div class="space-y-4">
+              <% @projects.each do |project| %>
+                <div class="border border-gray-200 rounded-md p-4 hover:bg-gray-50">
+                  <h3 class="font-medium text-gray-900"><%= project.title %></h3>
+                  <p class="text-sm text-gray-600 mt-1"><%= project.description %></p>
+                </div>
+              <% end %>
+            </div>
+          </div>
+          ```
+          
+          **BT Tailwind Best Practices:**
+          - Use BT's design tokens: bg-white, text-gray-900, border-gray-200
+          - Follow BT responsive patterns: sm:, md:, lg:, xl:
+          - Use BT component utilities: space-y-*, divide-y, ring-*
+          - Leverage BT theme classes: .btn, .card, .form-input (Tailwind-based)
+          - NEVER mix Bootstrap classes - BT is pure Tailwind CSS
+          
+          **Essential BT Commands:**
+          - bin/resolve --interactive (for file discovery)
+          - bin/super-scaffold (alias for rails generate super_scaffold)
+          - bin/theme (for theme customization)
+          - bin/hack (for local gem development)
+        STRATEGY
+        file_structure: %w[
+          app/models app/controllers/account app/controllers/api/v1 
+          app/views/account config/routes/api config/locales config/models
+          spec/models spec/controllers spec/system spec/requests
+        ],
+        conventions: [
+          'Andrew Culver namespacing rules',
+          'Team-scoped multi-tenancy by default', 
+          'Super Scaffolding for all CRUD',
+          'bin/resolve before any file modification',
+          'Prefer concerns over full ejection',
+          'Full plugin ecosystem utilization',
+          'Role-based permissions with inheritance',
+          'Billing and Stripe integration ready',
+          'Tailwind CSS styling - NEVER Bootstrap',
+          'BT theme design tokens and components'
+        ],
+        commands: [
+          'bundle install',
+          'bin/resolve --interactive',
+          'rails generate super_scaffold',
+          'bin/resolve ClassName --eject --open',
+          'rails db:migrate',
+          'rspec'
+        ]
+      }
+    end
+
+    # CRITICAL: Merge agent worktree changes back to main project
+    def merge_agent_changes_to_main(phase_results)
+      Logger.info("🔄 Merging agent changes from worktrees to main project...")
+      
+      merged_count = 0
+      
+      phase_results.each do |result|
+        next unless result[:success] && result[:agent_info]
+        
+        agent_info = result[:agent_info]
+        worktree_path = agent_info[:worktree_path]
+        role = agent_info[:role]
+        
+        if worktree_path && Dir.exist?(worktree_path)
+          begin
+            # Copy all relevant files from worktree to main project
+            merge_worktree_to_main(worktree_path, role)
+            merged_count += 1
+            Logger.info("✅ Merged #{role} agent changes from #{worktree_path}")
+          rescue StandardError => e
+            Logger.error("❌ Failed to merge #{role} agent changes: #{e.message}")
+          end
+        end
+      end
+      
+      Logger.info("🎯 Merged changes from #{merged_count} agents to main project")
+    end
+
+    def merge_worktree_to_main(worktree_path, role)
+      main_dir = Dir.pwd
+      
+      # Define critical directories to sync
+      sync_paths = [
+        'app/',
+        'db/',
+        'config/',
+        'spec/',
+        'test/',
+        'lib/',
+        'Gemfile'
+      ]
+      
+      sync_paths.each do |path|
+        source_path = File.join(worktree_path, path)
+        target_path = File.join(main_dir, path)
+        
+        if File.exist?(source_path)
+          if File.directory?(source_path)
+            # Recursively copy directory contents
+            copy_directory_contents(source_path, target_path, role)
+          else
+            # Copy individual file
+            copy_file_if_newer(source_path, target_path, role)
+          end
+        end
+      end
+    end
+
+    def copy_directory_contents(source_dir, target_dir, role)
+      require 'fileutils'
+      
+      Dir.glob(File.join(source_dir, '**', '*')).each do |source_file|
+        next if File.directory?(source_file)
+        
+        relative_path = source_file.sub(source_dir + '/', '')
+        target_file = File.join(target_dir, relative_path)
+        
+        # Ensure target directory exists
+        FileUtils.mkdir_p(File.dirname(target_file))
+        
+        # Copy file if newer or different
+        copy_file_if_newer(source_file, target_file, role)
+      end
+    end
+
+    def copy_file_if_newer(source_file, target_file, role)
+      require 'fileutils'
+      
+      # Always copy from agents - they have the latest work
+      if File.exist?(source_file)
+        begin
+          FileUtils.cp(source_file, target_file)
+          Logger.debug("📄 Copied #{role}: #{File.basename(target_file)}")
+        rescue StandardError => e
+          Logger.warn("⚠️ Failed to copy #{source_file}: #{e.message}")
+        end
+      end
+    end
+
+    def finalize_orchestration_results
+      Logger.info("🎯 Finalizing orchestration results...")
+      
+      begin
+        # Add all merged changes
+        system("git add -A")
+        
+        # Create comprehensive commit
+        commit_message = "EnhanceSwarm orchestration: Multi-agent implementation complete"
+        result = system("git commit -m '#{commit_message}' 2>/dev/null")
+        
+        if result
+          Logger.info("📝 All orchestration changes committed successfully")
+        else
+          Logger.info("ℹ️ No new changes to commit (agents may have worked in isolation)")
+        end
+        
+        # Clean up completed worktrees
+        cleanup_worktrees
+        
+      rescue StandardError => e
+        Logger.warn("⚠️ Failed to finalize results: #{e.message}")
+      end
+    end
+
+    def cleanup_worktrees
+      worktree_dir = '.enhance_swarm/worktrees'
+      return unless Dir.exist?(worktree_dir)
+      
+      Dir.glob(File.join(worktree_dir, '*')).each do |worktree_path|
+        if Dir.exist?(worktree_path)
+          begin
+            # Remove the worktree using git
+            system("git worktree remove --force #{worktree_path} 2>/dev/null")
+            Logger.debug("🧹 Cleaned up worktree: #{File.basename(worktree_path)}")
+          rescue StandardError => e
+            Logger.warn("⚠️ Failed to cleanup worktree #{worktree_path}: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end