aidp 0.34.0 → 0.39.3

data/lib/aidp/execute/work_loop_runner.rb

@@ -71,10 +71,16 @@ module Aidp
         @unit_scheduler = nil
 
         # Initialize thinking depth manager for intelligent model selection
+        # Issue #375: Enable autonomous mode by default for work loops
         require_relative "../harness/thinking_depth_manager"
-        @thinking_depth_manager = options[:thinking_depth_manager] || Aidp::Harness::ThinkingDepthManager.new(config, root_dir: @project_dir)
+        @thinking_depth_manager = options[:thinking_depth_manager] || Aidp::Harness::ThinkingDepthManager.new(
+          config,
+          root_dir: @project_dir,
+          autonomous_mode: true  # Issue #375: Work loops use autonomous mode
+        )
         @consecutive_failures = 0
         @last_tier = nil
+        @last_model = nil  # Issue #375: Track last used model
 
         # Initialize style guide selector for intelligent section selection
         @style_guide_selector = options[:style_guide_selector] || Aidp::StyleGuide::Selector.new(project_dir: project_dir)
@@ -281,26 +287,9 @@ module Aidp
           process_task_filing(agent_result)
 
           transition_to(:test)
-          # Run all configured checks
-          test_results = @test_runner.run_tests
-          lint_results = @test_runner.run_linters
-          build_results = @test_runner.run_builds
-          doc_results = @test_runner.run_documentation
-
-          # Run formatters only if agent marked work complete (per issue #234)
-          formatter_results = if agent_marked_complete?(agent_result)
-            @test_runner.run_formatters
-          else
-            {success: true, output: "Formatters: Skipped (work not complete)", failures: [], required_failures: []}
-          end
 
-          all_results = {
-            tests: test_results,
-            lints: lint_results,
-            formatters: formatter_results,
-            builds: build_results,
-            docs: doc_results
-          }
+          # Run all configured checks using phase-based execution
+          all_results = run_phase_based_commands(agent_result)
 
           record_periodic_checkpoint(all_results)
 
@@ -308,28 +297,21 @@ module Aidp
           track_failures_and_escalate(all_results)
 
           # All required checks must pass for completion
-          all_checks_pass = test_results[:success] &&
-            lint_results[:success] &&
-            formatter_results[:success] &&
-            build_results[:success] &&
-            doc_results[:success]
+          all_checks_pass = all_results.values.all? { |r| r[:success] }
 
           # Check task completion status
           task_completion_result = check_task_completion
           agent_completed = agent_marked_complete?(agent_result)
 
           # FIX for issue #391: Comprehensive logging at completion decision point
+          results_summary = all_results.transform_values { |r| r[:success] }
           Aidp.log_debug("work_loop", "completion_decision_point",
             iteration: @iteration_count,
             all_checks_pass: all_checks_pass,
             agent_marked_complete: agent_completed,
             task_completion_complete: task_completion_result[:complete],
             task_completion_reason: task_completion_result[:reason],
-            test_success: test_results[:success],
-            lint_success: lint_results[:success],
-            formatter_success: formatter_results[:success],
-            build_success: build_results[:success],
-            doc_success: doc_results[:success])
+            phase_results: results_summary)
 
           if all_checks_pass
             transition_to(:pass)
@@ -341,6 +323,16 @@ module Aidp
                   iteration: @iteration_count,
                   reason: task_completion_result[:reason])
 
+                # Run full_loop phase commands before final completion
+                full_loop_results = run_full_loop_commands
+                unless full_loop_results[:success]
+                  # Full loop commands failed - continue iterating
+                  display_message("  Full loop commands failed, continuing work loop", type: :warning)
+                  all_results[:full_loop] = full_loop_results
+                  transition_to(:fail)
+                  next
+                end
+
                 transition_to(:done)
                 record_final_checkpoint(all_results)
                 display_task_summary
@@ -510,8 +502,9 @@ module Aidp
 
       def append_evaluation_feedback_to_prompt(evaluation)
         feedback_section = build_evaluation_feedback_section(evaluation)
-
-        @prompt_manager.append(feedback_section)
+        current_prompt = @prompt_manager.read || ""
+        updated_prompt = current_prompt + "\n\n---\n\n" + feedback_section
+        @prompt_manager.write(updated_prompt, step_name: @step_name)
 
         Aidp.log_debug("work_loop", "appended_evaluation_feedback",
           iteration: @iteration_count,
@@ -771,6 +764,81 @@ module Aidp
         result[:status] == "completed" || prompt_marked_complete?
       end
 
+      # Run commands using the new phase-based execution model
+      # This method supports both the new generic commands and legacy category-specific commands
+      #
+      # @param agent_result [Hash] Result from the agent (used to determine if on_completion should run)
+      # @return [Hash] Results keyed by phase/category
+      def run_phase_based_commands(agent_result)
+        all_results = {}
+
+        # Check if we're using the new generic commands or legacy category commands
+        if @config.respond_to?(:commands) && @config.commands.any?
+          # New phase-based execution
+          each_unit_results = @test_runner.run_commands_for_phase(:each_unit)
+          all_results[:each_unit] = each_unit_results
+
+          # Run on_completion commands only if agent marked work complete
+          if agent_marked_complete?(agent_result)
+            on_completion_results = @test_runner.run_commands_for_phase(:on_completion)
+            all_results[:on_completion] = on_completion_results
+          else
+            all_results[:on_completion] = {
+              success: true,
+              output: "On-completion commands: Skipped (work not complete)",
+              failures: [],
+              required_failures: []
+            }
+          end
+
+          Aidp.log_debug("work_loop", "ran_phase_based_commands",
+            each_unit_success: each_unit_results[:success],
+            on_completion_success: all_results[:on_completion][:success],
+            agent_completed: agent_marked_complete?(agent_result))
+        else
+          # Legacy category-based execution for backwards compatibility
+          all_results = run_legacy_category_commands(agent_result)
+        end
+
+        all_results
+      end
+
+      # Run full_loop phase commands (only at end of entire work loop)
+      def run_full_loop_commands
+        return {success: true, output: "", failures: [], required_failures: []} unless @config.respond_to?(:commands)
+
+        full_loop_results = @test_runner.run_commands_for_phase(:full_loop)
+
+        Aidp.log_debug("work_loop", "ran_full_loop_commands",
+          success: full_loop_results[:success],
+          command_count: full_loop_results[:results_by_command]&.size || 0)
+
+        full_loop_results
+      end
+
+      # Run commands using legacy category-based approach (backwards compatibility)
+      def run_legacy_category_commands(agent_result)
+        test_results = @test_runner.run_tests
+        lint_results = @test_runner.run_linters
+        build_results = @test_runner.run_builds
+        doc_results = @test_runner.run_documentation
+
+        # Run formatters only if agent marked work complete (per issue #234)
+        formatter_results = if agent_marked_complete?(agent_result)
+          @test_runner.run_formatters
+        else
+          {success: true, output: "Formatters: Skipped (work not complete)", failures: [], required_failures: []}
+        end
+
+        {
+          tests: test_results,
+          lints: lint_results,
+          formatters: formatter_results,
+          builds: build_results,
+          docs: doc_results
+        }
+      end
+
       # Diagnose all failures (tests, lints, formatters, builds, docs)
       # Returns diagnostic information to help agent understand what went wrong
       def diagnose_failures(all_results)
@@ -818,6 +886,8 @@ module Aidp
         user_input = format_user_input(context[:user_input])
         deterministic_outputs = Array(context[:deterministic_outputs])
         previous_summary = context[:previous_agent_summary]
+        task_description = format_task_description(user_input, previous_summary)
+        additional_context = format_additional_context(context[:additional_context])
 
         initial_prompt = build_initial_prompt_content(
           template: template_content,
@@ -826,7 +896,9 @@ module Aidp
           user_input: user_input,
           step_name: @step_name,
           deterministic_outputs: deterministic_outputs,
-          previous_agent_summary: previous_summary
+          previous_agent_summary: previous_summary,
+          task_description: task_description,
+          additional_context: additional_context
         )
 
         @prompt_manager.write(initial_prompt, step_name: @step_name)
@@ -910,6 +982,42 @@ module Aidp
         parts.join("\n\n")
       end
 
+      def format_task_description(user_input, previous_agent_summary)
+        description = build_task_description(user_input, {previous_agent_summary: previous_agent_summary}).to_s.strip
+        description.empty? ? "_No task description provided._" : description
+      end
+
+      def format_additional_context(additional_context)
+        return "_No additional context._" if additional_context.nil?
+
+        formatted = case additional_context
+        when String
+          additional_context.strip
+        when Array
+          additional_context.map do |entry|
+            if entry.is_a?(Hash)
+              entry.map { |key, value| "#{key}: #{value}" }.join(", ")
+            else
+              entry.to_s
+            end
+          end.reject(&:empty?).map { |line| "- #{line}" }.join("\n")
+        when Hash
+          additional_context.map { |key, value| "- #{key}: #{value}" }.join("\n")
+        else
+          additional_context.to_s
+        end
+
+        formatted.empty? ? "_No additional context._" : formatted
+      end
+
+      def interpolate_task_template(template, task_description:, additional_context:)
+        return "" if template.nil?
+
+        template
+          .gsub("{{task_description}}", task_description.to_s)
+          .gsub("{{additional_context}}", additional_context.to_s)
+      end
+
       # Extract relevant tags from input and spec
       def extract_tags(user_input, step_spec)
         tags = []
@@ -930,16 +1038,16 @@ module Aidp
         tags.uniq
       end
 
-      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:, deterministic_outputs:, previous_agent_summary:)
+      def build_initial_prompt_content(template:, prd:, style_guide:, user_input:, step_name:, deterministic_outputs:, previous_agent_summary:, task_description:, additional_context:)
         parts = []
 
         parts << "# Work Loop: #{step_name}"
         parts << ""
         parts << "## Instructions"
         parts << "You are working in a work loop. Your responsibilities:"
-        parts << "1. Read this PROMPT.md file to understand what needs to be done"
+        parts << "1. Read this file (`.aidp/PROMPT.md`) to understand what needs to be done"
         parts << "2. Complete the work described below"
-        parts << "3. **IMPORTANT**: Edit this PROMPT.md file yourself to:"
+        parts << "3. **IMPORTANT**: Edit this `.aidp/PROMPT.md` file to:"
         parts << "   - Remove completed items"
         parts << "   - Update with current status"
         parts << "   - Keep it concise (remove unnecessary context)"
@@ -948,7 +1056,7 @@ module Aidp
         parts << "5. If tests/linters fail, you'll see the errors in the next iteration"
         parts << ""
         parts << "## Completion Criteria"
-        parts << "Mark this step COMPLETE by adding this line to PROMPT.md:"
+        parts << "Mark this step COMPLETE by adding this line to `.aidp/PROMPT.md`:"
         parts << "```"
         parts << "STATUS: COMPLETE"
         parts << "```"
@@ -988,7 +1096,11 @@ module Aidp
         end
 
         parts << "## Task Template"
-        parts << template
+        parts << interpolate_task_template(
+          template,
+          task_description: task_description,
+          additional_context: additional_context
+        )
         parts << ""
 
         parts.join("\n")
@@ -1261,7 +1373,7 @@ module Aidp
           parts << "### Step 3: Complete the Work Loop"
           parts << "Only after ALL tasks are done:"
           parts << "- Verify tests pass"
-          parts << "- Add STATUS: COMPLETE to PROMPT.md"
+          parts << "- Add STATUS: COMPLETE to `.aidp/PROMPT.md`"
           parts << ""
           parts << "### Task Rules"
           parts << "- **At least ONE task must be filed** - completion blocked without tasks"
@@ -1285,7 +1397,7 @@ module Aidp
         end
 
         parts << "## Completion Criteria"
-        parts << "Mark this step COMPLETE by adding these lines to PROMPT.md:"
+        parts << "Mark this step COMPLETE by adding these lines to `.aidp/PROMPT.md`:"
         parts << "```"
         parts << "STATUS: COMPLETE"
         if @config.task_completion_required?
@@ -2144,15 +2256,83 @@ module Aidp
         end
       end
 
+      # Maximum escalation depth to prevent infinite recursion
+      MAX_ESCALATION_DEPTH = 5
+
       # Select model based on current thinking depth tier
       # Returns [provider_name, model_name, model_data]
-      def select_model_for_current_tier
+      # Issue #375: Uses intelligent model selection in autonomous mode
+      # @param escalation_depth [Integer] Current recursion depth (prevents infinite loops)
+      def select_model_for_current_tier(escalation_depth: 0)
         current_tier = @thinking_depth_manager.current_tier
+        provider = @provider_manager.current_provider
+
+        # Issue #375: In autonomous mode, use intelligent model selection
+        # that considers previous attempts and prefers untested models
+        if @thinking_depth_manager.autonomous_mode?
+          model_name = @thinking_depth_manager.select_next_model(provider: provider)
+          if model_name
+            @last_model = model_name
+            Aidp.logger.debug("work_loop", "Selected model intelligently",
+              tier: current_tier,
+              provider: provider,
+              model: model_name,
+              step: @step_name,
+              iteration: @iteration_count)
+            return [provider, model_name, {}]
+          end
+
+          # No model from intelligent selection - check if we should escalate
+          escalation_check = @thinking_depth_manager.should_escalate_tier?(provider: provider)
+          if escalation_check[:should_escalate] && escalation_depth < MAX_ESCALATION_DEPTH
+            # Attempt escalation to get access to higher-tier models
+            new_tier = @thinking_depth_manager.escalate_tier_intelligent(provider: provider)
+            if new_tier
+              Aidp.logger.info("work_loop", "Escalated tier after exhausting models",
+                from: current_tier,
+                to: new_tier,
+                reason: escalation_check[:reason])
+              # Retry selection with new tier (increment depth to prevent infinite recursion)
+              return select_model_for_current_tier(escalation_depth: escalation_depth + 1)
+            else
+              Aidp.logger.warn("work_loop", "Escalation recommended but not possible",
+                tier: current_tier,
+                reason: "at_max_tier_or_blocked")
+              # Fall through to standard selection as last resort
+            end
+          elsif escalation_depth >= MAX_ESCALATION_DEPTH
+            Aidp.logger.error("work_loop", "Max escalation depth reached - model selection exhausted",
+              depth: escalation_depth,
+              tier: current_tier,
+              provider: provider)
+            raise Aidp::Harness::NoModelAvailableError.new(
+              tier: current_tier,
+              provider: provider
+            )
+          end
+          # Fall through to standard selection if escalation not recommended or not possible
+        end
+
+        # Standard model selection (non-autonomous or fallback)
         provider_name, model_name, model_data = @thinking_depth_manager.select_model_for_tier(
           current_tier,
-          provider: @provider_manager.current_provider
+          provider: provider
         )
 
+        # Validate that we got a usable model
+        if model_name.nil?
+          Aidp.logger.error("work_loop", "No model available after standard selection",
+            tier: current_tier,
+            provider: provider_name)
+          raise Aidp::Harness::NoModelAvailableError.new(
+            tier: current_tier,
+            provider: provider_name || provider
+          )
+        end
+
+        # Track the selected model for attempt recording
+        @last_model = model_name
+
         Aidp.logger.debug("work_loop", "Selected model for tier",
           tier: current_tier,
           provider: provider_name,
@@ -2164,8 +2344,20 @@ module Aidp
       end
 
       # Track test/lint/formatter/build/doc failures and escalate tier if needed
+      # Issue #375: Uses intelligent escalation that tries all models in tier first
       def track_failures_and_escalate(all_results)
         all_pass = all_results.values.all? { |result| result[:success] }
+        provider = @provider_manager.current_provider
+        model = @last_model
+
+        # Record model attempt with success/failure
+        if model
+          @thinking_depth_manager.record_model_attempt(
+            provider: provider,
+            model: model,
+            success: all_pass
+          )
+        end
 
         if all_pass
           # Reset failure count on success
@@ -2174,19 +2366,75 @@ module Aidp
           # Increment failure count
           @consecutive_failures += 1
 
-          # Check if we should escalate based on consecutive failures
-          if @thinking_depth_manager.should_escalate_on_failures?(@consecutive_failures)
+          # Issue #375: Use intelligent escalation in autonomous mode
+          if @thinking_depth_manager.autonomous_mode?
+            intelligent_escalate_thinking_tier(provider)
+          elsif @thinking_depth_manager.should_escalate_on_failures?(@consecutive_failures)
+            # Legacy behavior for non-autonomous mode
             escalate_thinking_tier("consecutive_failures")
           end
         end
 
-        # Check complexity-based escalation
+        # Check complexity-based escalation (applies to both modes)
         changed_files = get_changed_files
         if @thinking_depth_manager.should_escalate_on_complexity?(
           files_changed: changed_files.size,
           modules_touched: estimate_modules_touched(changed_files)
         )
-          escalate_thinking_tier("complexity_threshold")
+          # In autonomous mode, only escalate if intelligent check allows
+          if @thinking_depth_manager.autonomous_mode?
+            intelligent_escalate_thinking_tier(provider, reason: "complexity_threshold")
+          else
+            escalate_thinking_tier("complexity_threshold")
+          end
+        end
+      end
+
+      # Issue #375: Intelligent tier escalation that tries all models in current tier first
+      def intelligent_escalate_thinking_tier(provider, reason: nil)
+        escalation_check = @thinking_depth_manager.should_escalate_tier?(provider: provider)
+
+        unless escalation_check[:should_escalate]
+          # Log why we're not escalating yet
+          case escalation_check[:reason]
+          when "untested_models_remain"
+            display_message("  ℹ️  Not escalating tier: #{escalation_check[:untested_count]} untested models remain", type: :info)
+          when "below_min_attempts"
+            display_message("  ℹ️  Not escalating tier: #{escalation_check[:current]}/#{escalation_check[:required]} attempts made", type: :info)
+          end
+
+          Aidp.log_debug("work_loop", "Intelligent escalation blocked",
+            reason: escalation_check[:reason],
+            details: escalation_check)
+          return
+        end
+
+        # Proceed with escalation
+        old_tier = @thinking_depth_manager.current_tier
+        new_tier = @thinking_depth_manager.escalate_tier_intelligent(
+          provider: provider,
+          reason: reason || escalation_check[:reason]
+        )
+
+        if new_tier
+          display_message("  ⬆️  Escalated thinking tier: #{old_tier} → #{new_tier} (#{reason || escalation_check[:reason]})", type: :warning)
+          display_message("     Total attempts in #{old_tier}: #{escalation_check[:total_attempts]}", type: :info)
+
+          Aidp.logger.info("work_loop", "Intelligent tier escalation",
+            from: old_tier,
+            to: new_tier,
+            reason: reason || escalation_check[:reason],
+            step: @step_name,
+            iteration: @iteration_count,
+            model_attempts_summary: @thinking_depth_manager.model_attempts_summary)
+
+          # Reset last tier to trigger display of new tier
+          @last_tier = nil
+        else
+          Aidp.logger.debug("work_loop", "Cannot escalate tier further",
+            current: @thinking_depth_manager.current_tier,
+            max: @thinking_depth_manager.max_tier,
+            reason: reason)
         end
       end
 

data/lib/aidp/firewall/provider_requirements_collector.rb

@@ -2,15 +2,7 @@
 
 require "yaml"
 require "fileutils"
-require_relative "../providers/base"
-require_relative "../providers/anthropic"
-require_relative "../providers/cursor"
-require_relative "../providers/github_copilot"
-require_relative "../providers/gemini"
-require_relative "../providers/kilocode"
-require_relative "../providers/opencode"
-require_relative "../providers/codex"
-require_relative "../providers/aider"
+require "agent_harness"
 
 module Aidp
   module Firewall
@@ -233,24 +225,16 @@ module Aidp
 
       private
 
-      # Get list of all provider classes
+      # Get list of all provider classes from AgentHarness registry
       def provider_classes
-        [
-          Aidp::Providers::Anthropic,
-          Aidp::Providers::Cursor,
-          Aidp::Providers::GithubCopilot,
-          Aidp::Providers::Gemini,
-          Aidp::Providers::Kilocode,
-          Aidp::Providers::Opencode,
-          Aidp::Providers::Codex,
-          Aidp::Providers::Aider
-        ]
+        registry = AgentHarness::Providers::Registry.instance
+        registry.all.map { |name| registry.get(name) }
       end
 
-      # Extract provider name from class name
+      # Extract provider name from provider class
       def extract_provider_name(provider_class)
-        # Convert Aidp::Providers::GithubCopilot to "github_copilot"
-        provider_class.name.split("::").last.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+        # AgentHarness providers have provider_name class method
+        provider_class.provider_name.to_s
       end
 
       # Default path to firewall config file