aidp 0.23.0 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dedfe324bb5255c43e42a4ac3f716bb99f9db453ae436a1e2aa57b68754a28f
-  data.tar.gz: 24b5a225e474c14dabad326455e4d5286e175dc6a929a1bffab4ffb29c1c063c
+  metadata.gz: e2ec07f1c36212b7ace8e467e098fc3bcd917dc0738e27125bbddcef9bbcc30e
+  data.tar.gz: edbc40f6c50b581729d185186eae3510e8c23885f12655c46868117af361f31a
 SHA512:
-  metadata.gz: b842c15a0169d3b3c7361cbdf633b5bb66d0189f40fb16e12099436b3db7eda3e983fb624326b2160dd018d63090feae2b92042f46758990c31cef9172252d36
-  data.tar.gz: 1c614a680d74d56fff4561a62eee471ab1d8f7b8b2cc801786da25a63c12b142948f8e418477a4b479b3b119abe2275b954d9202662f7acbb36cdd82401a68eb
+  metadata.gz: f6472e33b88cf45f0c0abc5131dd608ba20d73480074552275d6d886222357c435023845fa8762b7f527268ba34fc2d3841d504309c8c068adbc38d6ac41f12b
+  data.tar.gz: 4283ba15ee02985603adbdba0be476adec35efc9fa6730a01beef1eac50d068647f3560aa03d75fcdb24ffc102e742bc1c3d9ff53fe95662a20241c711b54ae7

data/lib/aidp/cli.rb

@@ -1264,6 +1264,9 @@ module Aidp
           end
         end
 
+        # Initialize logger for watch mode
+        setup_logging(Dir.pwd)
+
         # Load watch safety configuration
         config_manager = Aidp::Harness::ConfigManager.new(Dir.pwd)
         config = config_manager.config || {}

data/lib/aidp/execute/work_loop_runner.rb

@@ -77,7 +77,7 @@ module Aidp
         display_guard_policy_status
         display_pending_tasks
 
-        @unit_scheduler = WorkLoopUnitScheduler.new(units_config)
+        @unit_scheduler = WorkLoopUnitScheduler.new(units_config, project_dir: @project_dir)
         base_context = context.dup
 
         loop do
@@ -97,6 +97,8 @@ module Aidp
 
           agentic_payload = if unit.name == :decide_whats_next
             run_decider_agentic_unit(enriched_context)
+          elsif unit.name == :diagnose_failures
+            run_diagnose_agentic_unit(enriched_context)
           else
             run_primary_agentic_unit(step_spec, enriched_context)
           end
@@ -148,7 +150,27 @@ module Aidp
           transition_to(:ready) unless @current_state == :ready
 
           transition_to(:apply_patch)
-          agent_result = apply_patch
+
+          # Wrap agent call in exception handling for true fix-forward
+          begin
+            agent_result = apply_patch
+          rescue => e
+            # Convert exception to error result for fix-forward handling
+            Aidp.logger.error("work_loop", "Exception during agent call",
+              step: @step_name,
+              iteration: @iteration_count,
+              error: e.message,
+              error_class: e.class.name,
+              backtrace: e.backtrace&.first(5))
+
+            display_message("  ⚠️  Exception during agent call: #{e.class.name}: #{e.message}", type: :error)
+
+            # Append exception to PROMPT.md so agent can see and fix it
+            append_exception_to_prompt(e)
+
+            # Continue to next iteration with fix-forward pattern
+            next
+          end
 
           # Process agent output for task filing signals
           process_task_filing(agent_result)
@@ -223,6 +245,34 @@ module Aidp
         )
       end
 
+      def run_diagnose_agentic_unit(context)
+        Aidp.logger.info("work_loop", "Running diagnose_failures agentic unit", step: @step_name)
+
+        prompt = build_diagnose_prompt(context)
+
+        agent_result = @provider_manager.execute_with_provider(
+          @provider_manager.current_provider,
+          prompt,
+          {
+            step_name: @step_name,
+            iteration: @iteration_count,
+            project_dir: @project_dir,
+            mode: :diagnose_failures
+          }
+        )
+
+        requested = AgentSignalParser.extract_next_unit(agent_result[:output])
+
+        build_agentic_payload(
+          agent_result: agent_result,
+          response: agent_result,
+          summary: agent_result[:output],
+          completed: false,
+          terminate: false,
+          requested_next: requested
+        )
+      end
+
       def units_config
         if @config.respond_to?(:work_loop_units_config)
           @config.work_loop_units_config
@@ -243,41 +293,94 @@ module Aidp
       end
 
       def build_decider_prompt(context)
-        outputs = Array(context[:deterministic_outputs])
-        summary = context[:previous_agent_summary]
-
-        sections = []
-        sections << "# Decide Next Work Loop Unit"
-        sections << ""
-        sections << "You are operating in the Aidp work loop. Determine what should happen next."
-        sections << ""
-        sections << "## Recent Deterministic Outputs"
-
-        if outputs.empty?
-          sections << "- None recorded yet."
-        else
-          outputs.each do |entry|
-            sections << "- #{entry[:name]} (status: #{entry[:status]}, finished_at: #{entry[:finished_at]})"
-            sections << "  Output: #{entry[:output_path] || "n/a"}"
-          end
-        end
+        template = load_work_loop_template("decide_whats_next.md", default_decider_template)
+        replacements = {
+          "{{DETERMINISTIC_OUTPUTS}}" => format_deterministic_outputs(context[:deterministic_outputs]),
+          "{{PREVIOUS_AGENT_SUMMARY}}" => format_previous_agent_summary(context[:previous_agent_summary])
+        }
+        replacements.reduce(template) { |body, (token, value)| body.gsub(token, value) }
+      end
 
-        if summary
-          sections << ""
-          sections << "## Previous Agent Summary"
-          sections << summary
-        end
+      def build_diagnose_prompt(context)
+        template = load_work_loop_template("diagnose_failures.md", default_diagnose_template)
+        replacements = {
+          "{{DETERMINISTIC_OUTPUTS}}" => format_deterministic_outputs(context[:deterministic_outputs]),
+          "{{PREVIOUS_AGENT_SUMMARY}}" => format_previous_agent_summary(context[:previous_agent_summary])
+        }
+        replacements.reduce(template) { |body, (token, value)| body.gsub(token, value) }
+      end
+
+      def load_work_loop_template(relative_path, fallback)
+        template_path = File.join(@project_dir, "templates", "work_loop", relative_path)
+        return File.read(template_path) if File.exist?(template_path)
 
-        sections << ""
-        sections << "## Instructions"
-        sections << "- Decide whether to run another deterministic unit or resume agentic editing."
-        sections << "- Announce your decision with `NEXT_UNIT: <unit_name>`."
-        sections << "- Valid values: names defined in configuration, `agentic`, or `wait_for_github`."
-        sections << "- Provide a concise rationale below."
-        sections << ""
-        sections << "## Rationale"
+        fallback
+      rescue => e
+        Aidp.logger.warn("work_loop", "Unable to load #{relative_path}", error: e.message)
+        fallback
+      end
+
+      def default_decider_template
+        <<~TEMPLATE
+          # Decide Next Work Loop Unit
+
+          ## Deterministic Outputs
+
+          {{DETERMINISTIC_OUTPUTS}}
+
+          ## Previous Agent Summary
+
+          {{PREVIOUS_AGENT_SUMMARY}}
+
+          ## Guidance
+          - Decide whether to run another deterministic unit or resume agentic editing.
+          - Announce your decision with `NEXT_UNIT: <unit_name>`.
+          - Valid values: names defined in configuration, `agentic`, or `wait_for_github`.
+          - Provide a concise rationale below.
 
-        sections.join("\n")
+          ## Rationale
+        TEMPLATE
+      end
+
+      def default_diagnose_template
+        <<~TEMPLATE
+          # Diagnose Failures
+
+          ## Recent Deterministic Outputs
+
+          {{DETERMINISTIC_OUTPUTS}}
+
+          ## Previous Agent Summary
+
+          {{PREVIOUS_AGENT_SUMMARY}}
+
+          ## Instructions
+          - Identify the root cause of the failures above.
+          - Recommend the next concrete action (another deterministic unit, agentic editing, or waiting).
+          - Emit `NEXT_UNIT: <unit_name>` on its own line.
+
+          ## Analysis
+        TEMPLATE
+      end
+
+      def format_deterministic_outputs(entries)
+        data = Array(entries)
+        return "- None recorded yet." if data.empty?
+
+        data.map do |entry|
+          name = entry[:name] || "unknown_unit"
+          status = entry[:status] || "unknown"
+          finished_at = entry[:finished_at]&.to_s || "unknown"
+          output = entry[:output_path] || "n/a"
+          "- #{name} (status: #{status}, finished_at: #{finished_at})\n  Output: #{output}"
+        end.join("\n")
+      end
+
+      def format_previous_agent_summary(summary)
+        content = summary.to_s.strip
+        return "_No previous agent summary._" if content.empty?
+
+        content
       end
 
       # Transition to a new state in the fix-forward state machine
@@ -544,16 +647,50 @@ module Aidp
         prompt_content = @prompt_manager.read
         return {status: "error", message: "PROMPT.md not found"} unless prompt_content
 
-        # Send to provider via provider_manager
-        @provider_manager.execute_with_provider(
-          @provider_manager.current_provider,
-          prompt_content,
-          {
-            step_name: @step_name,
-            iteration: @iteration_count,
-            project_dir: @project_dir
-          }
-        )
+        # Prepend work loop instructions to every iteration
+        full_prompt = build_work_loop_header(@step_name, @iteration_count) + "\n\n" + prompt_content
+
+        # 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
+          @provider_manager.execute_with_provider(
+            @provider_manager.current_provider,
+            full_prompt,
+            {
+              step_name: @step_name,
+              iteration: @iteration_count,
+              project_dir: @project_dir
+            }
+          )
+        end
+      end
+
+      def build_work_loop_header(step_name, iteration)
+        parts = []
+        parts << "# Work Loop: #{step_name} (Iteration #{iteration})"
+        parts << ""
+        parts << "## Instructions"
+        parts << "You are working in a work loop. Your responsibilities:"
+        parts << "1. Read the task description below to understand what needs to be done"
+        parts << "2. **Write/edit code files** to implement the required changes"
+        parts << "3. Run tests to verify your changes work correctly"
+        parts << "4. Update the task list in PROMPT.md as you complete items"
+        parts << "5. When ALL tasks are complete and tests pass, mark the step COMPLETE"
+        parts << ""
+        parts << "## Important Notes"
+        parts << "- You have full file system access - create and edit files as needed"
+        parts << "- The working directory is: #{@project_dir}"
+        parts << "- After you finish, tests and linters will run automatically"
+        parts << "- If tests/linters fail, you'll see the errors in the next iteration and can fix them"
+        parts << ""
+        parts << "## Completion Criteria"
+        parts << "Mark this step COMPLETE by adding this line to PROMPT.md:"
+        parts << "```"
+        parts << "STATUS: COMPLETE"
+        parts << "```"
+        parts << ""
+        parts.join("\n")
       end
 
       def prompt_marked_complete?
@@ -598,6 +735,9 @@ module Aidp
           failures << ""
         end
 
+        strategy = build_failure_strategy(test_results, lint_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 << ""
 
@@ -608,7 +748,48 @@ module Aidp
         updated_prompt = current_prompt + "\n\n---\n\n" + failures.join("\n")
         @prompt_manager.write(updated_prompt, step_name: @step_name)
 
-        display_message("  [NEXT_PATCH] Added failure reports and diagnostic to PROMPT.md", type: :warning)
+        display_message("  [NEXT_PATCH] Added failure reports, strategy, and diagnostic to PROMPT.md", type: :warning)
+      end
+
+      # Append exception details to PROMPT.md for fix-forward handling
+      # This allows the agent to see and fix errors that occur during execution
+      def append_exception_to_prompt(exception)
+        error_report = []
+
+        error_report << "## Fix-Forward Exception in Iteration #{@iteration_count}"
+        error_report << ""
+        error_report << "**CRITICAL**: An exception occurred during this iteration. Please analyze and fix the underlying issue."
+        error_report << ""
+        error_report << "### Exception Details"
+        error_report << "- **Type**: `#{exception.class.name}`"
+        error_report << "- **Message**: #{exception.message}"
+        error_report << ""
+
+        if exception.backtrace && !exception.backtrace.empty?
+          error_report << "### Stack Trace (First 10 lines)"
+          error_report << "```"
+          exception.backtrace.first(10).each do |line|
+            error_report << line
+          end
+          error_report << "```"
+          error_report << ""
+        end
+
+        error_report << "### Required Action"
+        error_report << "1. Analyze the exception type and message"
+        error_report << "2. Review the stack trace to identify the source"
+        error_report << "3. Fix the underlying code issue"
+        error_report << "4. Ensure the fix doesn't break existing functionality"
+        error_report << ""
+        error_report << "**Fix-forward instructions**: Do not rollback changes. Identify the root cause and fix it in the next iteration."
+        error_report << ""
+
+        # Append to PROMPT.md
+        current_prompt = @prompt_manager.read
+        updated_prompt = current_prompt + "\n\n---\n\n" + error_report.join("\n")
+        @prompt_manager.write(updated_prompt, step_name: @step_name)
+
+        display_message("  [EXCEPTION] Added exception details to PROMPT.md for fix-forward", type: :error)
       end
 
       # Check if we should reinject the style guide at this iteration
@@ -651,6 +832,32 @@ module Aidp
         reminder.join("\n")
       end
 
+      def build_failure_strategy(test_results, lint_results)
+        return [] if test_results[:success] && lint_results[: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
+
+        unless lint_results[:success]
+          commands = format_command_list(lint_results[:failures])
+          lines << "- Execute #{commands} and fix each reported offense."
+        end
+
+        lines << ""
+        lines
+      end
+
+      def format_command_list(failures)
+        commands = Array(failures).map { |failure| failure[:command] }.compact
+        commands = ["the configured command"] if commands.empty?
+        commands.map { |cmd| "`#{cmd}`" }.join(" or ")
+      end
+
       # Load current step's template content
       def load_current_template
         return nil unless @step_name

data/lib/aidp/execute/work_loop_unit_scheduler.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "deterministic_unit"
 require_relative "../logger"
 
@@ -18,18 +19,21 @@ module Aidp
 
       attr_reader :last_agentic_summary
 
-      def initialize(units_config, clock: Time)
+      def initialize(units_config, project_dir:, clock: Time)
         @clock = clock
+        @project_dir = project_dir
         @deterministic_definitions = build_deterministic_definitions(units_config[:deterministic])
         @defaults = default_options.merge(units_config[:defaults] || {})
         @pending_units = []
+        @initial_unit_requests = read_initial_unit_requests
         @deterministic_history = []
         @deterministic_state = Hash.new { |h, key| h[key] = default_deterministic_state }
         @agentic_runs = []
         @last_agentic_summary = nil
         @consecutive_deciders = 0
         @completed = false
-        @started = false
+        apply_initial_requests
+        @started = @pending_units.any?
       end
 
       def next_unit
@@ -173,6 +177,27 @@ module Aidp
         end
       end
 
+      def read_initial_unit_requests
+        return [] unless @project_dir
+
+        path = File.join(@project_dir, ".aidp", "work_loop", "initial_units.txt")
+        return [] unless File.exist?(path)
+
+        requests = File.readlines(path, chomp: true).map(&:strip).reject(&:empty?)
+        File.delete(path)
+        requests
+      rescue => e
+        Aidp.logger.warn("work_loop", "Failed to read initial work loop requests", error: e.message)
+        []
+      end
+
+      def apply_initial_requests
+        Array(@initial_unit_requests).each do |request|
+          queue_requested_unit(request.to_sym)
+        end
+        @initial_unit_requests = []
+      end
+
       def default_deterministic_state
         {last_run_at: nil, current_backoff: nil}
       end

data/lib/aidp/harness/condition_detector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Aidp
   module Harness
     # Detects run conditions (rate limits, user feedback, completion, errors)
@@ -15,14 +17,16 @@ module Aidp
             /429/i,
             /rate.{0,20}exceeded/i,
             /throttled/i,
-            /limit.{0,20}exceeded/i
+            /limit.{0,20}exceeded/i,
+            /session limit/i
           ],
           # Anthropic/Claude specific
           anthropic: [
             /rate limit exceeded/i,
             /too many requests/i,
             /quota.{0,20}exceeded/i,
-            /anthropic.{0,20}rate.{0,20}limit/i
+            /anthropic.{0,20}rate.{0,20}limit/i,
+            /session limit reached/i
           ],
           # OpenAI specific
           openai: [
@@ -143,10 +147,10 @@ module Aidp
 
         # Rate limit reset time patterns
         @reset_time_patterns = [
-          /reset.{0,20}in.{0,20}(\d+).{0,20}seconds/i,
-          /retry.{0,20}after.{0,20}(\d+).{0,20}seconds/i,
+          /reset(?:s)?\s+in\s+(\d+)\s+seconds/i,
+          /retry\s+after\s+(\d+)\s+seconds/i,
           /wait[^\d]*(\d+)[^\d]*seconds/i,
-          /(\d+).{0,20}seconds.{0,20}until.{0,20}reset/i,
+          /(\d+)\s+seconds\s+until\s+reset/i,
           /reset.{0,20}at.{0,20}(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/i,
           /retry.{0,20}after.{0,20}(\d{4}-\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2})/i
         ]
@@ -168,7 +172,18 @@ module Aidp
           result[:output],
           result[:response],
           result[:body]
-        ].compact.join(" ")
+        ].compact.join(" ").strip
+
+        return nil if text_content.empty?
+
+        {
+          provider: provider,
+          detected_at: Time.now,
+          reset_time: extract_reset_time(text_content),
+          retry_after: extract_retry_after(text_content),
+          limit_type: detect_limit_type(text_content, provider),
+          message: text_content
+        }
 
         return false if text_content.empty?
 
@@ -205,17 +220,34 @@ module Aidp
 
       # Extract reset time from rate limit message
       def extract_reset_time(text_content)
+        # Handle expressions like "resets 4am" or "reset at 4:30pm"
+        time_of_day_match = text_content.match(/reset(?:s)?(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)/i)
+        if time_of_day_match
+          hour = time_of_day_match[1].to_i
+          minute = time_of_day_match[2] ? time_of_day_match[2].to_i : 0
+          meridiem = time_of_day_match[3].downcase
+
+          hour %= 12
+          hour += 12 if meridiem == "pm"
+
+          now = Time.now
+          reset_time = Time.new(now.year, now.month, now.day, hour, minute, 0, now.utc_offset)
+          reset_time += 86_400 if reset_time <= now
+          return reset_time
+        end
+
         @reset_time_patterns.each do |pattern|
           match = text_content.match(pattern)
           next unless match
 
           if match[1].match?(/^\d+$/)
             # Seconds from now
-            Time.now + match[1].to_i
+            return Time.now + match[1].to_i
           else
             # Specific timestamp
             begin
-              Time.parse(match[1])
+              parsed_time = Time.parse(match[1])
+              return parsed_time if parsed_time
             rescue ArgumentError
               nil
             end
@@ -246,6 +278,8 @@ module Aidp
 
       # Detect the type of rate limit
       def detect_limit_type(text_content, provider)
+        return "session_limit" if text_content.match?(/session limit/i)
+
         case provider&.to_s&.downcase
         when "anthropic", "claude"
           if text_content.match?(/requests per minute/i)

data/lib/aidp/harness/config_manager.rb

@@ -10,6 +10,8 @@ module Aidp
     class ConfigManager
       include ProviderTypeChecker
 
+      attr_reader :project_dir
+
       def initialize(project_dir = Dir.pwd)
         @project_dir = project_dir
         @loader = ConfigLoader.new(project_dir)
@@ -101,6 +103,11 @@ module Aidp
         }
       end
 
+      # Get max retries (alias for backward compatibility with ErrorHandler)
+      def max_retries(options = {})
+        retry_config(options)[:max_attempts]
+      end
+
       # Get circuit breaker configuration
       def circuit_breaker_config(options = {})
         harness_config = harness_config(options)

data/lib/aidp/harness/config_schema.rb

@@ -886,6 +886,31 @@ module Aidp
                     type: :string
                   }
                 },
+                dangerous_mode: {
+                  type: :hash,
+                  required: false,
+                  default: {},
+                  properties: {
+                    enabled: {
+                      type: :boolean,
+                      required: false,
+                      default: false
+                    },
+                    flags: {
+                      type: :array,
+                      required: false,
+                      default: [],
+                      items: {
+                        type: :string
+                      }
+                    },
+                    auto_enable_in_devcontainer: {
+                      type: :boolean,
+                      required: false,
+                      default: true
+                    }
+                  }
+                },
                 models: {
                   type: :array,
                   required: false,