aidp 0.34.0 → 0.39.3

data/lib/aidp/harness/configuration.rb

@@ -171,29 +171,50 @@ module Aidp
         work_loop_config.fetch(:task_completion_required, true)
       end
 
-      # Get test commands
+      # Get all generic deterministic commands
+      # Returns array of command configs with normalized structure:
+      # [{name:, command:, required:, run_after:, category:, timeout_seconds:}]
+      def commands
+        @commands ||= load_commands
+      end
+
+      # Get commands filtered by execution phase
+      # @param phase [Symbol] :each_unit, :full_loop, or :on_completion
+      # @return [Array<Hash>] Commands configured for the specified phase
+      def commands_for_phase(phase)
+        commands.select { |cmd| cmd[:run_after] == phase.to_sym }
+      end
+
+      # Get commands filtered by category
+      # @param category [Symbol] :test, :lint, :formatter, :build, :documentation, etc.
+      # @return [Array<Hash>] Commands in the specified category
+      def commands_for_category(category)
+        commands.select { |cmd| cmd[:category] == category.to_sym }
+      end
+
+      # Get test commands (filtered from generic commands for backwards compatibility)
       def test_commands
-        normalize_commands(work_loop_config[:test_commands] || [])
+        commands_for_category(:test).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
       end
 
-      # Get lint commands
+      # Get lint commands (filtered from generic commands for backwards compatibility)
       def lint_commands
-        normalize_commands(work_loop_config[:lint_commands] || [])
+        commands_for_category(:lint).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
       end
 
-      # Get formatter commands
+      # Get formatter commands (filtered from generic commands for backwards compatibility)
       def formatter_commands
-        normalize_commands(work_loop_config[:formatter_commands] || [])
+        commands_for_category(:formatter).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
       end
 
-      # Get build commands
+      # Get build commands (filtered from generic commands for backwards compatibility)
       def build_commands
-        normalize_commands(work_loop_config[:build_commands] || [])
+        commands_for_category(:build).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
       end
 
-      # Get documentation commands
+      # Get documentation commands (filtered from generic commands for backwards compatibility)
       def documentation_commands
-        normalize_commands(work_loop_config[:documentation_commands] || [])
+        commands_for_category(:documentation).map { |cmd| {command: cmd[:command], required: cmd[:required]} }
       end
 
       # Get output filtering configuration
@@ -440,6 +461,34 @@ module Aidp
         thinking_config[:max_tier] || default_thinking_config[:max_tier]
       end
 
+      # Get maximum tier for autonomous contexts (watch mode, work loops)
+      # Restricts escalation to standard tier by default to prevent cost explosion
+      # Issue #375: Thinking tiers escalate too quickly in autonomous operations
+      def autonomous_max_tier
+        thinking_config[:autonomous_max_tier] || default_thinking_config[:autonomous_max_tier]
+      end
+
+      # Get escalation configuration for autonomous contexts
+      # Controls how models are tried before tier escalation
+      def autonomous_escalation_config
+        thinking_config[:autonomous_escalation] || default_autonomous_escalation_config
+      end
+
+      # Minimum attempts per model before trying next model in tier
+      def min_attempts_per_model
+        autonomous_escalation_config[:min_attempts_per_model] || 2
+      end
+
+      # Minimum total attempts across all models before tier escalation
+      def min_total_attempts_before_escalation
+        autonomous_escalation_config[:min_total_attempts] || 10
+      end
+
+      # Whether to retry failed models after exhausting untested models
+      def retry_failed_models?
+        autonomous_escalation_config[:retry_failed_models] != false
+      end
+
       # Check if provider switching for tier is allowed
       def allow_provider_switch_for_tier?
         thinking_config[:allow_provider_switch] != false
@@ -857,6 +906,157 @@ module Aidp
         end
       end
 
+      # Load commands from configuration, supporting both new generic format
+      # and legacy category-specific format for backwards compatibility
+      def load_commands
+        commands = []
+
+        # Load from new generic commands array if present
+        raw_commands = work_loop_config[:commands] || []
+        commands.concat(normalize_generic_commands(raw_commands))
+
+        # Load from legacy category-specific arrays for backwards compatibility
+        commands.concat(load_legacy_commands)
+
+        Aidp.log_debug("configuration", "loaded_commands",
+          total: commands.size,
+          from_generic: raw_commands.size,
+          from_legacy: commands.size - raw_commands.size)
+
+        commands
+      end
+
+      # Normalize generic command format
+      # @param commands [Array] Raw command configurations
+      # @return [Array<Hash>] Normalized command configs
+      def normalize_generic_commands(commands)
+        return [] if commands.nil? || commands.empty?
+
+        commands.each_with_index.map do |cmd, index|
+          case cmd
+          when String
+            {
+              name: "command_#{index}",
+              command: cmd,
+              required: true,
+              run_after: :each_unit,
+              category: :custom,
+              timeout_seconds: nil
+            }
+          when Hash
+            normalize_generic_command_hash(cmd, index)
+          else
+            raise ConfigurationError, "Command must be a string or hash, got: #{cmd.class}"
+          end
+        end
+      end
+
+      # Normalize a single generic command hash
+      def normalize_generic_command_hash(cmd, index)
+        command_value = cmd[:command] || cmd["command"]
+        unless command_value.is_a?(String) && !command_value.empty?
+          raise ConfigurationError, "Command must be a non-empty string, got: #{command_value.inspect}"
+        end
+
+        name = cmd[:name] || cmd["name"] || "command_#{index}"
+        required = fetch_boolean(cmd, :required, true)
+        run_after_raw = cmd[:run_after] || cmd["run_after"] || "each_unit"
+        run_after = normalize_run_after(run_after_raw)
+        category_raw = cmd[:category] || cmd["category"] || "custom"
+        category = category_raw.to_s.to_sym
+        timeout = cmd[:timeout_seconds] || cmd["timeout_seconds"]
+
+        {
+          name: name.to_s,
+          command: command_value,
+          required: required,
+          run_after: run_after,
+          category: category,
+          timeout_seconds: timeout
+        }
+      end
+
+      # Normalize run_after value to symbol
+      def normalize_run_after(value)
+        case value.to_s.downcase
+        when "each_unit", "each"
+          :each_unit
+        when "full_loop", "loop"
+          :full_loop
+        when "on_completion", "completion"
+          :on_completion
+        else
+          :each_unit
+        end
+      end
+
+      # Fetch boolean value from hash with symbol/string key support
+      def fetch_boolean(hash, key, default)
+        if hash.key?(key)
+          hash[key]
+        elsif hash.key?(key.to_s)
+          hash[key.to_s]
+        else
+          default
+        end
+      end
+
+      # Load commands from legacy category-specific configuration
+      # Converts old test_commands, lint_commands, etc. to generic format
+      def load_legacy_commands
+        commands = []
+
+        # Map legacy config keys to categories and default run_after
+        legacy_mappings = {
+          test_commands: {category: :test, run_after: :each_unit},
+          lint_commands: {category: :lint, run_after: :each_unit},
+          formatter_commands: {category: :formatter, run_after: :on_completion},
+          build_commands: {category: :build, run_after: :each_unit},
+          documentation_commands: {category: :documentation, run_after: :on_completion}
+        }
+
+        legacy_mappings.each do |config_key, defaults|
+          raw = work_loop_config[config_key] || []
+          next if raw.empty?
+
+          raw.each_with_index do |cmd, index|
+            normalized = normalize_legacy_command(cmd, defaults[:category], index)
+            normalized[:run_after] = defaults[:run_after]
+            commands << normalized
+          end
+        end
+
+        commands
+      end
+
+      # Normalize a legacy command to generic format
+      def normalize_legacy_command(cmd, category, index)
+        case cmd
+        when String
+          {
+            name: "#{category}_#{index}",
+            command: cmd,
+            required: true,
+            run_after: :each_unit,
+            category: category,
+            timeout_seconds: nil
+          }
+        when Hash
+          command_value = cmd[:command] || cmd["command"]
+          required = fetch_boolean(cmd, :required, true)
+          {
+            name: cmd[:name] || cmd["name"] || "#{category}_#{index}",
+            command: command_value,
+            required: required,
+            run_after: :each_unit,
+            category: category,
+            timeout_seconds: cmd[:timeout_seconds] || cmd["timeout_seconds"]
+          }
+        else
+          raise ConfigurationError, "Legacy command must be a string or hash, got: #{cmd.class}"
+        end
+      end
+
       def validate_configuration!
         errors = Aidp::Config.validate_harness_config(@config, @project_dir)
 
@@ -999,8 +1199,15 @@ module Aidp
         {
           enabled: true,
           max_iterations: 50,
+          # New generic commands array - replaces category-specific arrays
+          # Each command specifies when it runs (each_unit, full_loop, on_completion)
+          commands: [],
+          # Legacy category-specific arrays (for backwards compatibility)
           test_commands: [],
           lint_commands: [],
+          formatter_commands: [],
+          build_commands: [],
+          documentation_commands: [],
           guards: default_guards_config,
           units: default_units_config
         }
@@ -1114,15 +1321,27 @@ module Aidp
         {
           default_tier: "mini",  # Use mini tier by default for cost optimization
           max_tier: "pro",       # Max tier rarely needed; pro is sufficient for most tasks
+          autonomous_max_tier: "standard", # Issue #375: restrict autonomous operations to standard tier
           allow_provider_switch: true,
           auto_escalate: true,
           escalation_threshold: 2,
           escalation: default_escalation_config,
+          autonomous_escalation: default_autonomous_escalation_config,
           permissions_by_tier: {},
           overrides: {}
         }
       end
 
+      # Default autonomous escalation configuration (issue #375)
+      # Controls tier escalation in watch mode and work loops
+      def default_autonomous_escalation_config
+        {
+          min_attempts_per_model: 2,    # Each model needs min 2 attempts before trying next
+          min_total_attempts: 10,       # Min 10 total attempts before tier escalation
+          retry_failed_models: true     # Retry failed models after exhausting untested
+        }
+      end
+
       def default_escalation_config
         {
           on_fail_attempts: 2,

data/lib/aidp/harness/deprecation_cache.rb

@@ -8,15 +8,31 @@ module Aidp
     # Manages a dynamic cache of deprecated models detected at runtime
     # When deprecation errors are detected from provider APIs, models are
     # added to this cache with metadata (replacement, detected date, etc.)
+    #
+    # This class is designed to be extractable to the agent-harness gem.
+    # It uses dependency injection for logging to decouple from AIDP.
     class DeprecationCache
       class CacheError < StandardError; end
 
+      # Component name for logging
+      COMPONENT = "deprecation_cache"
+
       attr_reader :cache_path
 
-      def initialize(cache_path: nil, root_dir: nil)
+      # Initialize the deprecation cache.
+      #
+      # All parameters are optional for backward compatibility. Existing callers
+      # that don't pass a logger will use AIDP's built-in logging.
+      #
+      # @param cache_path [String, nil] custom cache file path (optional)
+      # @param root_dir [String, nil] root directory for default cache path (optional)
+      # @param logger [#log_info, #log_warn, #log_error, nil] logger instance (optional,
+      #   falls back to Aidp.log_* methods if nil)
+      def initialize(cache_path: nil, root_dir: nil, logger: nil)
         @root_dir = root_dir || safe_root_dir
         @cache_path = cache_path || default_cache_path
         @cache_data = nil
+        @logger = logger
         ensure_cache_directory
       end
 
@@ -36,8 +52,7 @@ module Aidp
         }.compact
 
         save_cache
-        Aidp.log_info("deprecation_cache", "Added deprecated model",
-          provider: provider, model: model_id, replacement: replacement)
+        log_info("added_deprecated_model", provider: provider, model: model_id, replacement: replacement)
       end
 
       # Check if a model is deprecated
@@ -78,8 +93,7 @@ module Aidp
         @cache_data["providers"].delete(provider) if @cache_data["providers"][provider].empty?
 
         save_cache
-        Aidp.log_info("deprecation_cache", "Removed deprecated model",
-          provider: provider, model: model_id)
+        log_info("removed_deprecated_model", provider: provider, model: model_id)
       end
 
       # Get full deprecation info for a model
@@ -95,7 +109,7 @@ module Aidp
       def clear!
         @cache_data = default_cache_structure
         save_cache
-        Aidp.log_info("deprecation_cache", "Cleared all deprecations")
+        log_info("cleared_all_deprecations")
       end
 
       # Get cache statistics
@@ -145,16 +159,14 @@ module Aidp
           @cache_data = default_cache_structure
         end
       rescue JSON::ParserError => e
-        Aidp.log_warn("deprecation_cache", "Invalid cache file, resetting",
-          error: e.message, path: @cache_path)
+        log_warn("invalid_cache_file_resetting", error: e.message, path: @cache_path)
         @cache_data = default_cache_structure
       end
 
       def save_cache
         File.write(@cache_path, JSON.pretty_generate(@cache_data))
       rescue => e
-        Aidp.log_error("deprecation_cache", "Failed to save cache",
-          error: e.message, path: @cache_path)
+        log_error("failed_to_save_cache", error: e.message, path: @cache_path)
         raise CacheError, "Failed to save deprecation cache: #{e.message}"
       end
 
@@ -168,10 +180,40 @@ module Aidp
 
       def validate_cache_structure
         unless @cache_data.is_a?(Hash) && @cache_data["providers"].is_a?(Hash)
-          Aidp.log_warn("deprecation_cache", "Invalid cache structure, resetting")
+          log_warn("invalid_cache_structure_resetting")
           @cache_data = default_cache_structure
         end
       end
+
+      # Logging helpers with fallback to Aidp.log_* if no logger injected.
+      #
+      # Design note: We intentionally treat nil and "not provided" the same way.
+      # Both mean "use AIDP's built-in logging". If you need to suppress logging
+      # entirely, pass a NullLogger that implements LoggerInterface but does nothing.
+      # This keeps the interface simple while supporting the gem extraction use case.
+      def log_info(message, **metadata)
+        if @logger
+          @logger.log_info(COMPONENT, message, **metadata)
+        else
+          Aidp.log_info(COMPONENT, message, **metadata)
+        end
+      end
+
+      def log_warn(message, **metadata)
+        if @logger
+          @logger.log_warn(COMPONENT, message, **metadata)
+        else
+          Aidp.log_warn(COMPONENT, message, **metadata)
+        end
+      end
+
+      def log_error(message, **metadata)
+        if @logger
+          @logger.log_error(COMPONENT, message, **metadata)
+        else
+          Aidp.log_error(COMPONENT, message, **metadata)
+        end
+      end
     end
   end
 end

data/lib/aidp/harness/enhanced_runner.rb

@@ -476,7 +476,7 @@ module Aidp
         }
 
         # Show backtrace in debug mode only
-        if ENV["DEBUG"]
+        if Aidp.debug_env_enabled?
           @tui.show_message("Backtrace: #{error.backtrace&.first(3)&.join("\n")}", :error)
         end
       end

data/lib/aidp/harness/error_handler.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "net/http"
+require "agent_harness"
 require_relative "../debug_mixin"
 require_relative "../concurrency"
-require_relative "../providers/error_taxonomy"
 require_relative "../errors"
 
 module Aidp
@@ -123,7 +123,7 @@ module Aidp
                 error: error,
                 provider: current_provider,
                 model: current_model_safely,
-                error_type: @error_classifier.classify_error(error)
+                error_type: @error_classifier.classify_error(error)[:error_type]
               }
 
               strategy = retry_strategy(error_info[:error_type])
@@ -264,7 +264,7 @@ module Aidp
 
         # Use ErrorTaxonomy to determine if error is retryable
         error_type = error_info[:error_type]
-        return false unless Aidp::Providers::ErrorTaxonomy.retryable?(error_type)
+        return false unless AgentHarness::ErrorTaxonomy.retryable?(error_type)
 
         # Check circuit breaker
         circuit_breaker_key = "#{error_info[:provider]}:#{error_info[:model]}"
@@ -622,7 +622,7 @@ module Aidp
           message = error.message.to_s
 
           # First, use ErrorTaxonomy to classify by message
-          category = Aidp::Providers::ErrorTaxonomy.classify_message(message)
+          category = AgentHarness::ErrorTaxonomy.classify_message(message)
 
           # Override with more specific classification based on error type
           case error
@@ -645,7 +645,13 @@ module Aidp
             :transient
           else
             # Use message-based classification from ErrorTaxonomy
-            category
+            # Map :unknown and :timeout to :transient for backwards compatibility
+            case category
+            when :unknown, :timeout
+              :transient
+            else
+              category
+            end
           end
         end
       end

data/lib/aidp/harness/provider_config.rb

@@ -2,6 +2,7 @@
 
 require_relative "config_manager"
 require_relative "provider_type_checker"
+require_relative "usage_limit"
 
 module Aidp
   module Harness
@@ -272,6 +273,41 @@ module Aidp
         }
       end
 
+      # Get usage limits configuration
+      #
+      # @param options [Hash] Options for config loading
+      # @return [Hash] Raw usage limits configuration hash
+      def usage_limits_config(options = {})
+        config = config(options)
+        limits = config[:usage_limits] || config["usage_limits"] || {}
+
+        {
+          enabled: limits[:enabled] == true,
+          period: limits[:period] || limits["period"] || "monthly",
+          reset_day: limits[:reset_day] || limits["reset_day"] || 1,
+          max_tokens: limits[:max_tokens] || limits["max_tokens"],
+          max_cost: limits[:max_cost] || limits["max_cost"],
+          tier_limits: limits[:tier_limits] || limits["tier_limits"] || {}
+        }
+      end
+
+      # Get usage limits as a UsageLimit value object
+      #
+      # @param options [Hash] Options for config loading
+      # @return [UsageLimit] UsageLimit instance
+      def usage_limit(options = {})
+        config = usage_limits_config(options)
+        UsageLimit.from_config(config)
+      end
+
+      # Check if usage limits are enabled for this provider
+      #
+      # @param options [Hash] Options for config loading
+      # @return [Boolean] True if limits are enabled
+      def usage_limits_enabled?(options = {})
+        usage_limits_config(options)[:enabled]
+      end
+
       # Get provider-specific harness configuration
       def harness_config(options = {})
         config = config(options)

data/lib/aidp/harness/provider_factory.rb

@@ -1,34 +1,29 @@
 # frozen_string_literal: true
 
+require "agent_harness"
 require_relative "provider_config"
-require_relative "../providers/base"
-require_relative "../providers/cursor"
-require_relative "../providers/anthropic"
-require_relative "../providers/gemini"
-require_relative "../providers/opencode"
-require_relative "../providers/kilocode"
-require_relative "../providers/github_copilot"
-require_relative "../providers/codex"
-require_relative "../providers/aider"
 
 module Aidp
   module Harness
     # Factory for creating configured provider instances
+    #
+    # Uses AgentHarness providers for all provider instantiation.
     class ProviderFactory
       # Expose for testability
       attr_reader :provider_instances, :provider_configs
 
-      PROVIDER_CLASSES = {
-        "cursor" => Aidp::Providers::Cursor,
-        "anthropic" => Aidp::Providers::Anthropic,
-        "claude" => Aidp::Providers::Anthropic,
-        "gemini" => Aidp::Providers::Gemini,
-        "opencode" => Aidp::Providers::Opencode,
-        "kilocode" => Aidp::Providers::Kilocode,
-        "github_copilot" => Aidp::Providers::GithubCopilot,
-        "codex" => Aidp::Providers::Codex,
-        "aider" => Aidp::Providers::Aider
-      }.freeze
+      # Provider class lookup - delegates to AgentHarness registry
+      def self.provider_classes
+        registry = AgentHarness::Providers::Registry.instance
+        registry.all.each_with_object({}) do |name, hash|
+          hash[name.to_s] = registry.get(name)
+          # Add aliases
+          hash["anthropic"] = registry.get(:claude) if name == :claude
+        end
+      end
+
+      # For backwards compatibility - expose PROVIDER_CLASSES as a method
+      PROVIDER_CLASSES = nil # Deprecated - use provider_classes method
 
       def initialize(config_manager = nil)
         @config_manager = config_manager || ConfigManager.new
@@ -122,19 +117,26 @@ module Aidp
         @provider_configs[provider_name.to_s] ||= ProviderConfig.new(provider_name, @config_manager)
       end
 
-      # Get provider class
+      # Get provider class from AgentHarness registry
       def provider_class(provider_name)
-        PROVIDER_CLASSES[provider_name.to_s]
+        name = provider_name.to_s
+        # Handle anthropic -> claude alias
+        name = "claude" if name == "anthropic"
+        AgentHarness::Providers::Registry.instance.get(name.to_sym)
+      rescue AgentHarness::ConfigurationError
+        nil
       end
 
       # Check if provider is supported
       def provider_supported?(provider_name)
-        PROVIDER_CLASSES.key?(provider_name.to_s)
+        name = provider_name.to_s
+        name = "claude" if name == "anthropic"
+        AgentHarness::Providers::Registry.instance.registered?(name.to_sym)
       end
 
       # Get supported provider names
       def supported_providers
-        PROVIDER_CLASSES.keys
+        AgentHarness::Providers::Registry.instance.all.map(&:to_s)
       end
 
       # Get configured provider names

data/lib/aidp/harness/provider_info.rb

@@ -154,7 +154,7 @@ module Aidp
         provider_instance.fetch_mcp_servers
       rescue => e
         log_rescue(e, component: "provider_info", action: "fetch_mcp_servers", fallback: [], provider: @provider_name)
-        warn "Failed to fetch MCP servers for #{@provider_name}: #{e.message}" if ENV["AIDP_DEBUG"]
+        warn "Failed to fetch MCP servers for #{@provider_name}: #{e.message}" if Aidp.debug_env_enabled?
         []
       end
 
@@ -359,17 +359,21 @@ module Aidp
       def provider_instance
         return @provider_instance if @provider_instance
 
-        # Load provider factory and get provider class
-        require_relative "provider_factory"
+        # Get provider class from AgentHarness registry
+        require "agent_harness"
 
-        provider_class = Aidp::Harness::ProviderFactory::PROVIDER_CLASSES[@provider_name]
+        name = @provider_name
+        name = "claude" if name == "anthropic"
+        provider_class = AgentHarness::Providers::Registry.instance.get(name.to_sym)
         return nil unless provider_class
 
         # Create provider instance
         @provider_instance = provider_class.new
+      rescue AgentHarness::ConfigurationError
+        nil
       rescue => e
         log_rescue(e, component: "provider_info", action: "create_provider_instance", fallback: nil, provider: @provider_name)
-        warn "Failed to create provider instance for #{@provider_name}: #{e.message}" if ENV["AIDP_DEBUG"]
+        warn "Failed to create provider instance for #{@provider_name}: #{e.message}" if Aidp.debug_env_enabled?
         nil
       end
 

data/lib/aidp/harness/provider_manager.rb

@@ -1118,8 +1118,8 @@ module Aidp
             end
             installed = !path.nil?
           when "cursor"
-            require_relative "../providers/cursor"
-            installed = Aidp::Providers::Cursor.available?
+            require "agent_harness"
+            installed = AgentHarness::Providers::Registry.instance.get(:cursor).available?
           end
         rescue LoadError => e
           log_rescue(e, component: "provider_manager", action: "check_provider_availability", fallback: false, provider: provider_name)