aidp 0.22.0 → 0.24.0

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,

data/lib/aidp/harness/configuration.rb

@@ -7,6 +7,8 @@ module Aidp
   module Harness
     # Handles loading and validation of harness configuration from aidp.yml
     class Configuration
+      attr_reader :project_dir
+
       def initialize(project_dir)
         @project_dir = project_dir
         @config = Aidp::Config.load_harness_config(project_dir)
@@ -600,7 +602,16 @@ module Aidp
 
       # Get devcontainer configuration
       def devcontainer_config
-        @config[:devcontainer] || default_devcontainer_config
+        return @devcontainer_config if defined?(@devcontainer_config)
+
+        raw_config = @config[:devcontainer] || @config["devcontainer"]
+        base = deep_dup(default_devcontainer_config)
+
+        @devcontainer_config = if raw_config.is_a?(Hash)
+          deep_merge_hashes(base, deep_symbolize_keys(raw_config))
+        else
+          base
+        end
       end
 
       # Check if devcontainer features are enabled
@@ -629,7 +640,10 @@ module Aidp
 
       # Get devcontainer permissions config
       def devcontainer_permissions
-        devcontainer_config[:permissions] || {}
+        permissions = devcontainer_config[:permissions]
+        return {} unless permissions.is_a?(Hash)
+
+        permissions.transform_keys { |key| key.to_sym }
       end
 
       # Check if dangerous filesystem operations are allowed in devcontainer
@@ -639,7 +653,15 @@ module Aidp
 
       # Get list of providers that should skip permission checks in devcontainer
       def devcontainer_skip_permission_checks
-        devcontainer_permissions[:skip_permission_checks] || []
+        permissions = devcontainer_config[:permissions]
+        list = nil
+
+        if permissions.is_a?(Hash)
+          list = permissions[:skip_permission_checks] || permissions["skip_permission_checks"]
+        end
+
+        list = default_skip_permission_checks if list.nil?
+        Array(list).map(&:to_s)
       end
 
       # Check if a specific provider should skip permission checks in devcontainer
@@ -843,7 +865,7 @@ module Aidp
               max_backoff_seconds: 1800,
               next: {
                 success: :agentic,
-                failure: :decide_whats_next,
+                failure: :diagnose_failures,
                 else: :decide_whats_next
               }
             },
@@ -856,7 +878,7 @@ module Aidp
               max_backoff_seconds: 1800,
               next: {
                 success: :agentic,
-                failure: :decide_whats_next,
+                failure: :diagnose_failures,
                 else: :decide_whats_next
               }
             },
@@ -1055,7 +1077,7 @@ module Aidp
           force_detection: nil,
           permissions: {
             dangerous_filesystem_ops: false,
-            skip_permission_checks: []
+            skip_permission_checks: ["claude"]
           },
           settings: {
             timeout_multiplier: 1.0,
@@ -1065,6 +1087,47 @@ module Aidp
         }
       end
 
+      def default_skip_permission_checks
+        Array(default_devcontainer_config.dig(:permissions, :skip_permission_checks)).map(&:to_s)
+      end
+
+      def deep_symbolize_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, val), memo|
+            memo[key.to_sym] = deep_symbolize_keys(val)
+          end
+        when Array
+          value.map { |item| deep_symbolize_keys(item) }
+        else
+          value
+        end
+      end
+
+      def deep_merge_hashes(base, overrides)
+        overrides.each do |key, value|
+          base[key] = if base[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge_hashes(base[key], value)
+          else
+            value
+          end
+        end
+        base
+      end
+
+      def deep_dup(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, val), memo|
+            memo[key] = deep_dup(val)
+          end
+        when Array
+          value.map { |item| deep_dup(item) }
+        else
+          value
+        end
+      end
+
       # Custom error class for configuration issues
       class ConfigurationError < StandardError; end
     end

data/lib/aidp/harness/error_handler.rb

@@ -3,6 +3,7 @@
 require "net/http"
 require_relative "../debug_mixin"
 require_relative "../concurrency"
+require_relative "../providers/error_taxonomy"
 
 module Aidp
   module Harness
@@ -252,9 +253,10 @@ module Aidp
       # Check if we should retry based on error type and strategy
       def should_retry?(error_info, strategy)
         return false unless strategy[:enabled]
-        return false if error_info[:error_type] == :rate_limit
-        return false if error_info[:error_type] == :authentication
-        return false if error_info[:error_type] == :permission_denied
+
+        # Use ErrorTaxonomy to determine if error is retryable
+        error_type = error_info[:error_type]
+        return false unless Aidp::Providers::ErrorTaxonomy.retryable?(error_type)
 
         # Check circuit breaker
         circuit_breaker_key = "#{error_info[:provider]}:#{error_info[:model]}"
@@ -337,7 +339,62 @@ module Aidp
 
       def initialize_retry_strategies
         @retry_strategies = {
-          # Network errors - retry with exponential backoff
+          # Transient errors - retry with exponential backoff
+          transient: {
+            name: "transient",
+            enabled: true,
+            max_retries: 3,
+            backoff_strategy: :exponential,
+            base_delay: 1.0,
+            max_delay: 30.0,
+            jitter: true
+          },
+
+          # Rate limited errors - no retry, immediate switch
+          rate_limited: {
+            name: "rate_limited",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Authentication expired - no retry, switch provider
+          auth_expired: {
+            name: "auth_expired",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Quota exceeded - no retry, switch provider
+          quota_exceeded: {
+            name: "quota_exceeded",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Permanent errors - no retry, escalate
+          permanent: {
+            name: "permanent",
+            enabled: false,
+            max_retries: 0,
+            backoff_strategy: :none,
+            base_delay: 0.0,
+            max_delay: 0.0,
+            jitter: false
+          },
+
+          # Legacy aliases for backward compatibility
           network_error: {
             name: "network_error",
             enabled: true,
@@ -347,8 +404,6 @@ module Aidp
             max_delay: 30.0,
             jitter: true
           },
-
-          # Server errors - retry with linear backoff
           server_error: {
             name: "server_error",
             enabled: true,
@@ -358,8 +413,6 @@ module Aidp
             max_delay: 10.0,
             jitter: true
           },
-
-          # Timeout errors - retry with exponential backoff
           timeout: {
             name: "timeout",
             enabled: true,
@@ -369,8 +422,6 @@ module Aidp
             max_delay: 15.0,
             jitter: true
           },
-
-          # Rate limit errors - no retry, immediate switch
           rate_limit: {
             name: "rate_limit",
             enabled: false,
@@ -380,8 +431,6 @@ module Aidp
             max_delay: 0.0,
             jitter: false
           },
-
-          # Authentication errors - no retry, escalate
           authentication: {
             name: "authentication",
             enabled: false,
@@ -391,8 +440,6 @@ module Aidp
             max_delay: 0.0,
             jitter: false
           },
-
-          # Permission denied - no retry, escalate
           permission_denied: {
             name: "permission_denied",
             enabled: false,
@@ -586,41 +633,36 @@ module Aidp
         private
 
         def classify_error_type(error)
-          return :unknown if error.nil?
+          return :transient if error.nil?
+
+          # Use standardized error taxonomy for classification
+          message = error.message.to_s
 
+          # First, use ErrorTaxonomy to classify by message
+          category = Aidp::Providers::ErrorTaxonomy.classify_message(message)
+
+          # Override with more specific classification based on error type
           case error
           when Timeout::Error
-            :timeout
+            :transient
           when Net::HTTPError
             case error.response.code.to_i
             when 429
-              :rate_limit
+              :rate_limited
             when 401, 403
-              :authentication
+              :auth_expired
             when 500..599
-              :server_error
+              :transient
+            when 400
+              :permanent
             else
-              :network_error
+              :transient
             end
           when SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH
-            :network_error
-          when StandardError
-            # Check error message for common patterns
-            message = error.message.downcase
-
-            if message.include?("rate limit") || message.include?("quota")
-              :rate_limit
-            elsif message.include?("timeout")
-              :timeout
-            elsif message.include?("auth") || message.include?("permission")
-              :authentication
-            elsif message.include?("server") || message.include?("internal")
-              :server_error
-            else
-              :default
-            end
+            :transient
           else
-            :default
+            # Use message-based classification from ErrorTaxonomy
+            category
           end
         end
       end
@@ -629,22 +671,41 @@ module Aidp
         def create_recovery_plan(error_info, _context = {})
           error_type = error_info[:error_type]
 
+          # Use ErrorTaxonomy to determine recovery strategy
           case error_type
-          when :rate_limit
+          when :rate_limited
             {
               action: :switch_provider,
               reason: "Rate limit reached, switching provider",
               priority: :high
             }
-          when :authentication, :permission_denied
-            # Previously we escalated immediately. Instead, attempt a provider switch
-            # so workflows can continue with alternate providers (e.g., Gemini, Cursor)
-            # while the user resolves credentials for the failing provider.
+          when :auth_expired
+            # Attempt a provider switch so workflows can continue with alternate providers
+            # while the user resolves credentials for the failing provider
             {
               action: :switch_provider,
-              reason: "Authentication/permission issue – switching provider to continue",
+              reason: "Authentication expired – switching provider to continue",
               priority: :critical
             }
+          when :quota_exceeded
+            {
+              action: :switch_provider,
+              reason: "Quota exceeded, switching provider",
+              priority: :high
+            }
+          when :transient
+            {
+              action: :switch_model,
+              reason: "Transient error, trying alternate model",
+              priority: :medium
+            }
+          when :permanent
+            {
+              action: :escalate,
+              reason: "Permanent error, requires manual intervention",
+              priority: :critical
+            }
+          # Legacy error type mappings for backward compatibility
           when :timeout
             {
               action: :switch_model,
@@ -655,7 +716,7 @@ module Aidp
             {
               action: :switch_provider,
               reason: "Network error, switching provider",
-              priority: :high
+              priority: :medium
             }
           when :server_error
             {
@@ -663,6 +724,18 @@ module Aidp
               reason: "Server error, switching provider",
               priority: :medium
             }
+          when :authentication, :permission_denied
+            {
+              action: :switch_provider,
+              reason: "Authentication/permission issue – switching provider to continue",
+              priority: :critical
+            }
+          when :rate_limit
+            {
+              action: :switch_provider,
+              reason: "Rate limit reached, switching provider",
+              priority: :high
+            }
           else
             {
               action: :switch_provider,