aidp 0.25.0 → 0.27.0

data/lib/aidp/execute/work_loop_runner.rb

@@ -8,6 +8,7 @@ require_relative "work_loop_unit_scheduler"
 require_relative "deterministic_unit"
 require_relative "agent_signal_parser"
 require_relative "../harness/test_runner"
+require_relative "../errors"
 
 module Aidp
   module Execute
@@ -46,10 +47,11 @@ module Aidp
         @project_dir = project_dir
         @provider_manager = provider_manager
         @config = config
+        @prompt = options[:prompt] || TTY::Prompt.new
         @prompt_manager = PromptManager.new(project_dir, config: config)
         @test_runner = Aidp::Harness::TestRunner.new(project_dir, config)
         @checkpoint = Checkpoint.new(project_dir)
-        @checkpoint_display = CheckpointDisplay.new
+        @checkpoint_display = CheckpointDisplay.new(prompt: @prompt)
         @guard_policy = GuardPolicy.new(project_dir, config.guards_config)
         @persistent_tasklist = PersistentTasklist.new(project_dir)
         @iteration_count = 0
@@ -59,6 +61,12 @@ module Aidp
         @state_history = []
         @deterministic_runner = DeterministicUnits::Runner.new(project_dir)
         @unit_scheduler = nil
+
+        # Initialize thinking depth manager for intelligent model selection
+        require_relative "../harness/thinking_depth_manager"
+        @thinking_depth_manager = options[:thinking_depth_manager] || Aidp::Harness::ThinkingDepthManager.new(config)
+        @consecutive_failures = 0
+        @last_tier = nil
       end
 
       # Execute a step using fix-forward work loop pattern
@@ -154,6 +162,10 @@ module Aidp
           # Wrap agent call in exception handling for true fix-forward
           begin
             agent_result = apply_patch
+          rescue Aidp::Errors::ConfigurationError
+            # Configuration errors should crash immediately (crash-early principle)
+            # Re-raise without catching
+            raise
           rescue => e
             # Convert exception to error result for fix-forward handling
             Aidp.logger.error("work_loop", "Exception during agent call",
@@ -172,23 +184,70 @@ module Aidp
             next
           end
 
+          # Check for fatal configuration errors (crash early per LLM_STYLE_GUIDE)
+          if agent_result[:status] == "error" && agent_result[:message]&.include?("No model available")
+            tier = @thinking_depth_manager.current_tier
+            provider = @provider_manager.current_provider
+
+            error_msg = "No model configured for thinking tier '#{tier}'.\n\n" \
+                       "Current provider: #{provider}\n" \
+                       "Required tier: #{tier}\n\n" \
+                       "To fix this, add a model to your aidp.yml:\n\n" \
+                       "thinking_depth:\n" \
+                       "  tiers:\n" \
+                       "    #{tier}:\n" \
+                       "      models:\n" \
+                       "        - provider: #{provider}\n" \
+                       "          model: <model-name>  # e.g., claude-3-5-sonnet-20241022\n\n" \
+                       "Or run: aidp models list\n" \
+                       "to see available models for your configured providers."
+
+            raise Aidp::Errors::ConfigurationError, error_msg
+          end
+
           # Process agent output for task filing signals
           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
+          }
+
+          record_periodic_checkpoint(all_results)
 
-          record_periodic_checkpoint(test_results, lint_results)
+          # Track failures and escalate thinking tier if needed
+          track_failures_and_escalate(all_results)
 
-          tests_pass = test_results[:success] && lint_results[:success]
+          # 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]
 
-          if tests_pass
+          if all_checks_pass
             transition_to(:pass)
 
             if agent_marked_complete?(agent_result)
               transition_to(:done)
-              record_final_checkpoint(test_results, lint_results)
+              record_final_checkpoint(all_results)
               display_message("✅ Step #{@step_name} completed after #{@iteration_count} iterations", type: :success)
               display_state_summary
               archive_and_cleanup
@@ -201,18 +260,18 @@ module Aidp
                 terminate: true
               )
             else
-              display_message("  Tests passed but work not marked complete", type: :info)
+              display_message("  All checks passed but work not marked complete", type: :info)
               transition_to(:next_patch)
             end
           else
             transition_to(:fail)
-            display_message("  Tests or linters failed", type: :warning)
+            display_message("  Required checks failed", type: :warning)
 
             transition_to(:diagnose)
-            diagnostic = diagnose_failures(test_results, lint_results)
+            diagnostic = diagnose_failures(all_results)
 
             transition_to(:next_patch)
-            prepare_next_iteration(test_results, lint_results, diagnostic)
+            prepare_next_iteration(all_results, diagnostic)
           end
         end
       end
@@ -222,14 +281,18 @@ module Aidp
 
         prompt = build_decider_prompt(context)
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
         agent_result = @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
+          provider_name,
           prompt,
           {
             step_name: @step_name,
             iteration: @iteration_count,
             project_dir: @project_dir,
-            mode: :decide_whats_next
+            mode: :decide_whats_next,
+            model: model_name
           }
         )
 
@@ -250,14 +313,18 @@ module Aidp
 
         prompt = build_diagnose_prompt(context)
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
         agent_result = @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
+          provider_name,
           prompt,
           {
             step_name: @step_name,
             iteration: @iteration_count,
             project_dir: @project_dir,
-            mode: :diagnose_failures
+            mode: :diagnose_failures,
+            model: model_name
           }
         )
 
@@ -421,27 +488,26 @@ module Aidp
         result[:status] == "completed" || prompt_marked_complete?
       end
 
-      # Diagnose test/lint failures
+      # Diagnose all failures (tests, lints, formatters, builds, docs)
       # Returns diagnostic information to help agent understand what went wrong
-      def diagnose_failures(test_results, lint_results)
+      def diagnose_failures(all_results)
         diagnostic = {
           iteration: @iteration_count,
           failures: []
         }
 
-        unless test_results[:success]
-          diagnostic[:failures] << {
-            type: "tests",
-            count: test_results[:failures]&.size || 0,
-            commands: test_results[:failures]&.map { |f| f[:command] } || []
-          }
-        end
+        # Check each result type for failures
+        all_results.each do |category, results|
+          next if results[:success]
+
+          # Only include required failures in diagnostic
+          required_failures = results[:required_failures] || results[:failures] || []
+          next if required_failures.empty?
 
-        unless lint_results[:success]
           diagnostic[:failures] << {
-            type: "linters",
-            count: lint_results[:failures]&.size || 0,
-            commands: lint_results[:failures]&.map { |f| f[:command] } || []
+            type: category.to_s,
+            count: required_failures.size,
+            commands: required_failures.map { |f| f[:command] }
           }
         end
 
@@ -650,17 +716,36 @@ module Aidp
         # Prepend work loop instructions to every iteration
         full_prompt = build_work_loop_header(@step_name, @iteration_count) + "\n\n" + prompt_content
 
+        # Select model based on thinking depth tier
+        provider_name, model_name, _model_data = select_model_for_current_tier
+
+        if provider_name.nil? || model_name.nil?
+          Aidp.logger.error("work_loop", "Failed to select model for tier",
+            tier: @thinking_depth_manager.current_tier,
+            step: @step_name,
+            iteration: @iteration_count)
+          return {status: "error", message: "No model available for tier #{@thinking_depth_manager.current_tier}"}
+        end
+
+        # Log model selection
+        tier = @thinking_depth_manager.current_tier
+        if @last_tier != tier
+          display_message("  💡 Using tier: #{tier} (#{provider_name}/#{model_name})", type: :info)
+          @last_tier = tier
+        end
+
         # CRITICAL: Change to project directory before calling provider
         # This ensures Claude CLI runs in the correct directory and can create files
         Dir.chdir(@project_dir) do
-          # Send to provider via provider_manager
+          # Send to provider via provider_manager with selected model
           @provider_manager.execute_with_provider(
-            @provider_manager.current_provider,
+            provider_name,
             full_prompt,
             {
               step_name: @step_name,
               iteration: @iteration_count,
-              project_dir: @project_dir
+              project_dir: @project_dir,
+              model: model_name
             }
           )
         end
@@ -701,7 +786,7 @@ module Aidp
         prompt_content.match?(/^STATUS:\s*COMPLETE/i)
       end
 
-      def prepare_next_iteration(test_results, lint_results, diagnostic = nil)
+      def prepare_next_iteration(all_results, diagnostic = nil)
         # Only append failures to PROMPT.md for agent to see
         # This follows fix-forward: never rollback, only add information for next patch
         failures = []
@@ -723,25 +808,30 @@ module Aidp
           failures << ""
         end
 
-        unless test_results[:success]
-          failures << "### Test Failures"
-          failures << test_results[:output]
-          failures << ""
-        end
+        # Add failure output for each category that has failures
+        category_labels = {
+          tests: "Test",
+          lints: "Linter",
+          formatters: "Formatter",
+          builds: "Build",
+          docs: "Documentation"
+        }
 
-        unless lint_results[:success]
-          failures << "### Linter Failures"
-          failures << lint_results[:output]
+        all_results.each do |category, results|
+          next if results[:success]
+
+          failures << "### #{category_labels[category]} Failures"
+          failures << results[:output]
           failures << ""
         end
 
-        strategy = build_failure_strategy(test_results, lint_results)
+        strategy = build_failure_strategy(all_results)
         failures.concat(strategy) unless strategy.empty?
 
         failures << "**Fix-forward instructions**: Do not rollback changes. Build on what exists and fix the failures above."
         failures << ""
 
-        return if test_results[:success] && lint_results[:success]
+        return if all_results.values.all? { |result| result[:success] }
 
         # Append failures to PROMPT.md and archive immediately (issue #224)
         current_prompt = @prompt_manager.read
@@ -832,20 +922,27 @@ module Aidp
         reminder.join("\n")
       end
 
-      def build_failure_strategy(test_results, lint_results)
-        return [] if test_results[:success] && lint_results[:success]
+      def build_failure_strategy(all_results)
+        return [] if all_results.values.all? { |result| result[:success] }
 
         lines = ["### Recovery Strategy", ""]
 
-        unless test_results[:success]
-          commands = format_command_list(test_results[:failures])
-          lines << "- Re-run #{commands} locally to reproduce the failing specs listed above."
-          lines << "- Triage the exact failures before moving on to new work."
-        end
+        category_strategies = {
+          tests: "Re-run %s locally to reproduce the failing specs listed above. Triage the exact failures before moving on to new work.",
+          lints: "Execute %s and fix each reported offense.",
+          formatters: "Run %s to fix formatting issues.",
+          builds: "Run %s to diagnose and fix build errors.",
+          docs: "Review and update documentation using %s to meet requirements."
+        }
+
+        all_results.each do |category, results|
+          next if results[:success]
+
+          strategy_template = category_strategies[category]
+          next unless strategy_template
 
-        unless lint_results[:success]
-          commands = format_command_list(lint_results[:failures])
-          lines << "- Execute #{commands} and fix each reported offense."
+          commands = format_command_list(results[:failures])
+          lines << "- #{strategy_template % commands}"
         end
 
         lines << ""
@@ -926,13 +1023,16 @@ module Aidp
       end
 
       # Record checkpoint at regular intervals
-      def record_periodic_checkpoint(test_results, lint_results)
+      def record_periodic_checkpoint(all_results)
         # Record every CHECKPOINT_INTERVAL iterations or on iteration 1
         return unless @iteration_count == 1 || (@iteration_count % CHECKPOINT_INTERVAL == 0)
 
         metrics = {
-          tests_passing: test_results[:success],
-          linters_passing: lint_results[:success]
+          tests_passing: all_results[:tests][:success],
+          linters_passing: all_results[:lints][:success],
+          formatters_passing: all_results[:formatters][:success],
+          builds_passing: all_results[:builds][:success],
+          docs_passing: all_results[:docs][:success]
         }
 
         checkpoint_data = @checkpoint.record_checkpoint(@step_name, @iteration_count, metrics)
@@ -947,10 +1047,13 @@ module Aidp
       end
 
       # Record final checkpoint when step completes
-      def record_final_checkpoint(test_results, lint_results)
+      def record_final_checkpoint(all_results)
         metrics = {
-          tests_passing: test_results[:success],
-          linters_passing: lint_results[:success],
+          tests_passing: all_results[:tests][:success],
+          linters_passing: all_results[:lints][:success],
+          formatters_passing: all_results[:formatters][:success],
+          builds_passing: all_results[:builds][:success],
+          docs_passing: all_results[:docs][:success],
           completed: true
         }
 
@@ -1114,6 +1217,100 @@ module Aidp
           display_message("   ✓ Confirmed", type: :success)
         end
       end
+
+      # Select model based on current thinking depth tier
+      # Returns [provider_name, model_name, model_data]
+      def select_model_for_current_tier
+        current_tier = @thinking_depth_manager.current_tier
+        provider_name, model_name, model_data = @thinking_depth_manager.select_model_for_tier(
+          current_tier,
+          provider: @provider_manager.current_provider
+        )
+
+        Aidp.logger.debug("work_loop", "Selected model for tier",
+          tier: current_tier,
+          provider: provider_name,
+          model: model_name,
+          step: @step_name,
+          iteration: @iteration_count)
+
+        [provider_name, model_name, model_data]
+      end
+
+      # Track test/lint/formatter/build/doc failures and escalate tier if needed
+      def track_failures_and_escalate(all_results)
+        all_pass = all_results.values.all? { |result| result[:success] }
+
+        if all_pass
+          # Reset failure count on success
+          @consecutive_failures = 0
+        else
+          # 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)
+            escalate_thinking_tier("consecutive_failures")
+          end
+        end
+
+        # Check complexity-based escalation
+        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")
+        end
+      end
+
+      # Escalate to next thinking tier
+      def escalate_thinking_tier(reason)
+        old_tier = @thinking_depth_manager.current_tier
+        new_tier = @thinking_depth_manager.escalate_tier(reason: reason)
+
+        if new_tier
+          display_message("  ⬆️  Escalated thinking tier: #{old_tier} → #{new_tier} (#{reason})", type: :warning)
+          Aidp.logger.info("work_loop", "Escalated thinking tier",
+            from: old_tier,
+            to: new_tier,
+            reason: reason,
+            step: @step_name,
+            iteration: @iteration_count,
+            consecutive_failures: @consecutive_failures)
+
+          # Reset last tier to trigger display of new tier
+          @last_tier = nil
+        else
+          Aidp.logger.debug("work_loop", "Cannot escalate tier further",
+            current: old_tier,
+            max: @thinking_depth_manager.max_tier,
+            reason: reason)
+        end
+      end
+
+      # Estimate number of modules touched based on file paths
+      def estimate_modules_touched(files)
+        # Group files by their top-level directory or module
+        modules = files.map do |file|
+          parts = file.split("/")
+          # Consider top 2 levels as module identifier
+          parts.take(2).join("/")
+        end.uniq
+
+        modules.size
+      end
+
+      # Get thinking depth status for display
+      def thinking_depth_status
+        {
+          current_tier: @thinking_depth_manager.current_tier,
+          max_tier: @thinking_depth_manager.max_tier,
+          can_escalate: @thinking_depth_manager.can_escalate?,
+          consecutive_failures: @consecutive_failures,
+          escalation_count: @thinking_depth_manager.escalation_count
+        }
+      end
     end
   end
 end

data/lib/aidp/execute/workflow_selector.rb

@@ -10,10 +10,10 @@ module Aidp
     class WorkflowSelector
       include Aidp::MessageDisplay
 
-      def initialize(prompt: TTY::Prompt.new)
+      def initialize(prompt: TTY::Prompt.new, workflow_selector: nil)
         @user_input = {}
         @prompt = prompt
-        @workflow_selector = Aidp::Workflows::Selector.new(prompt: @prompt)
+        @workflow_selector = workflow_selector || Aidp::Workflows::Selector.new(prompt: @prompt)
       end
 
       # Main entry point for interactive workflow selection

data/lib/aidp/harness/config_loader.rb

@@ -316,17 +316,19 @@ module Aidp
       def handle_validation_errors(errors)
         error_message = "Configuration validation failed:\n" + errors.join("\n")
 
-        # Log error
-        if defined?(Rails) && Rails.logger
-          Rails.logger.error(error_message)
-        else
-          warn(error_message)
+        # Log error (suppress in test/CI environments)
+        unless suppress_config_warnings?
+          if defined?(Rails) && Rails.logger
+            Rails.logger.error(error_message)
+          else
+            warn(error_message)
+          end
         end
 
         # In development, try to fix common issues
         if ENV["AIDP_ENV"] == "development" || ENV["RACK_ENV"] == "development"
           if @validator.fix_common_issues
-            warn("Attempted to fix configuration issues. Please review the updated configuration file.")
+            warn("Attempted to fix configuration issues. Please review the updated configuration file.") unless suppress_config_warnings?
           end
         end
       end
@@ -334,11 +336,13 @@ module Aidp
       def log_warnings(warnings)
         warning_message = "Configuration warnings:\n" + warnings.join("\n")
 
-        # Log warnings
-        if defined?(Rails) && Rails.logger
-          Rails.logger.warn(warning_message)
-        else
-          warn(warning_message)
+        # Log warnings (suppress in test/CI environments)
+        unless suppress_config_warnings?
+          if defined?(Rails) && Rails.logger
+            Rails.logger.warn(warning_message)
+          else
+            warn(warning_message)
+          end
         end
       end
 
@@ -390,6 +394,11 @@ module Aidp
           false
         end
       end
+
+      # Suppress configuration warnings in test/CI environments
+      def suppress_config_warnings?
+        ENV["RSPEC_RUNNING"] || ENV["CI"] || ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
+      end
     end
   end
 end

data/lib/aidp/harness/config_manager.rb

@@ -359,19 +359,19 @@ module Aidp
       def load_config_with_options(options)
         # Apply different loading strategies based on options
         if options[:mode]
-          @loader.get_mode_config(options[:mode], options[:force_reload])
+          @loader.mode_config(options[:mode], options[:force_reload])
         elsif options[:environment]
-          @loader.get_environment_config(options[:environment], options[:force_reload])
+          @loader.environment_config(options[:environment], options[:force_reload])
         elsif options[:step]
           @loader.get_step_config(options[:step], options[:force_reload])
         elsif options[:features]
-          @loader.get_config_with_features(options[:features], options[:force_reload])
+          @loader.config_with_features(options[:features], options[:force_reload])
         elsif options[:user]
           @loader.get_user_config(options[:user], options[:force_reload])
         elsif options[:time_based]
-          @loader.get_time_based_config(options[:force_reload])
+          @loader.time_based_config(options[:force_reload])
         elsif options[:overrides]
-          @loader.get_config_with_overrides(options[:overrides])
+          @loader.config_with_overrides(options[:overrides])
         else
           @loader.load_config(options[:force_reload])
         end

data/lib/aidp/harness/config_schema.rb

@@ -375,6 +375,9 @@ module Aidp
                 max_iterations: 50,
                 test_commands: [],
                 lint_commands: [],
+                formatter_commands: [],
+                build_commands: [],
+                documentation_commands: [],
                 units: {},
                 guards: {enabled: false},
                 version_control: {tool: "git", behavior: "nothing", conventional_commits: false},
@@ -397,18 +400,37 @@ module Aidp
                 test_commands: {
                   type: :array,
                   required: false,
-                  default: [],
-                  items: {
-                    type: :string
-                  }
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
                 },
                 lint_commands: {
                   type: :array,
                   required: false,
-                  default: [],
-                  items: {
-                    type: :string
-                  }
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                formatter_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                build_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
+                },
+                documentation_commands: {
+                  type: :array,
+                  required: false,
+                  default: []
+                  # Items can be strings or {command: string, required: boolean}
+                  # Validation handled in Configuration class for flexibility
                 },
                 units: {
                   type: :hash,