aidp 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00cbc8656c3ce1550f5246837062879c70a0206fa62c00a7bef6cd20979b9be5
-  data.tar.gz: 353616de5a90d4cf722673040d6e7fba09d60ff63618a3c135688202694e3075
+  metadata.gz: dcf4f30f93195b349c527dd5531e056ad566a34be1ed079ced4b5002f07a93f5
+  data.tar.gz: 22a7ef871ab691e0072a1bc8f1254784e1605f46d3edfc9585e91c3a21c5180f
 SHA512:
-  metadata.gz: 65109acb0af57d4fefccbefa626f928cec5faaa3eedb5dfe4c0141521e03d95c8f7ca2dac8455baebdf6c14d0cbcd6cd81557a0bf4b2f0cdadb62547f60b414d
-  data.tar.gz: ea289ac3406776ccc1c602795fe6fa0a54c09fe8b3729b7e0f3b0151ba2782613cc2fee68b1111f9f6b81c78efeb7d31e77ab233ea49fba48e6d5585505e60f8
+  metadata.gz: c5630eb8255464816006bb091b02666b29ac58b4a1e3e9136c17f79dff54762d6ebe16a4ec45df3f26c22047959121db04ef4e94904be5a4fb2e03320c6a6113
+  data.tar.gz: 5bdae7edfb7aad8ef03dd2274c4a8095bd927097cbd882a28856f0f753b46c4f1f0d8f756801c6df239bd13540355cbf9e53805b3bc815e5ac1cfc407d61c1c9

data/lib/aidp/harness/deprecation_cache.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Aidp
+  module Harness
+    # 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.)
+    class DeprecationCache
+      class CacheError < StandardError; end
+
+      attr_reader :cache_path
+
+      def initialize(cache_path: nil, root_dir: nil)
+        @root_dir = root_dir || safe_root_dir
+        @cache_path = cache_path || default_cache_path
+        @cache_data = nil
+        ensure_cache_directory
+      end
+
+      # Add a deprecated model to the cache
+      # @param provider [String] Provider name (e.g., "anthropic")
+      # @param model_id [String] Deprecated model ID
+      # @param replacement [String, nil] Replacement model ID (if known)
+      # @param reason [String, nil] Deprecation reason/message
+      def add_deprecated_model(provider:, model_id:, replacement: nil, reason: nil)
+        load_cache unless @cache_data
+
+        @cache_data["providers"][provider] ||= {}
+        @cache_data["providers"][provider][model_id] = {
+          "deprecated_at" => Time.now.iso8601,
+          "replacement" => replacement,
+          "reason" => reason
+        }.compact
+
+        save_cache
+        Aidp.log_info("deprecation_cache", "Added deprecated model",
+          provider: provider, model: model_id, replacement: replacement)
+      end
+
+      # Check if a model is deprecated
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID to check
+      # @return [Boolean]
+      def deprecated?(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id) != nil
+      end
+
+      # Get replacement model for a deprecated model
+      # @param provider [String] Provider name
+      # @param model_id [String] Deprecated model ID
+      # @return [String, nil] Replacement model ID or nil
+      def replacement_for(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id, "replacement")
+      end
+
+      # Get all deprecated models for a provider
+      # @param provider [String] Provider name
+      # @return [Array<String>] List of deprecated model IDs
+      def deprecated_models(provider:)
+        load_cache unless @cache_data
+        (@cache_data.dig("providers", provider) || {}).keys
+      end
+
+      # Remove a model from the deprecated cache
+      # Useful if a model comes back or was incorrectly marked
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID to remove
+      def remove_deprecated_model(provider:, model_id:)
+        load_cache unless @cache_data
+        return unless @cache_data.dig("providers", provider, model_id)
+
+        @cache_data["providers"][provider].delete(model_id)
+        @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)
+      end
+
+      # Get full deprecation info for a model
+      # @param provider [String] Provider name
+      # @param model_id [String] Model ID
+      # @return [Hash, nil] Deprecation metadata or nil
+      def info(provider:, model_id:)
+        load_cache unless @cache_data
+        @cache_data.dig("providers", provider, model_id)
+      end
+
+      # Clear all cached deprecations
+      def clear!
+        @cache_data = default_cache_structure
+        save_cache
+        Aidp.log_info("deprecation_cache", "Cleared all deprecations")
+      end
+
+      # Get cache statistics
+      # @return [Hash] Statistics about cached deprecations
+      def stats
+        load_cache unless @cache_data
+        {
+          providers: @cache_data["providers"].keys.sort,
+          total_deprecated: @cache_data["providers"].sum { |_, models| models.size },
+          by_provider: @cache_data["providers"].transform_values(&:size)
+        }
+      end
+
+      private
+
+      # Get a safe root directory for the cache
+      # Uses Dir.pwd if writable, otherwise falls back to tmpdir
+      def safe_root_dir
+        pwd = Dir.pwd
+        aidp_dir = File.join(pwd, ".aidp")
+
+        # Try to create the directory to test writability
+        begin
+          FileUtils.mkdir_p(aidp_dir) unless File.exist?(aidp_dir)
+          pwd
+        rescue Errno::EACCES, Errno::EROFS, Errno::EPERM
+          # Permission denied or read-only filesystem - use temp directory
+          require "tmpdir"
+          Dir.tmpdir
+        end
+      end
+
+      def default_cache_path
+        File.join(@root_dir, ".aidp", "deprecated_models.json")
+      end
+
+      def ensure_cache_directory
+        dir = File.dirname(@cache_path)
+        FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+      end
+
+      def load_cache
+        if File.exist?(@cache_path)
+          @cache_data = JSON.parse(File.read(@cache_path))
+          validate_cache_structure
+        else
+          @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)
+        @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)
+        raise CacheError, "Failed to save deprecation cache: #{e.message}"
+      end
+
+      def default_cache_structure
+        {
+          "version" => "1.0",
+          "updated_at" => Time.now.iso8601,
+          "providers" => {}
+        }
+      end
+
+      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")
+          @cache_data = default_cache_structure
+        end
+      end
+    end
+  end
+end

data/lib/aidp/harness/ruby_llm_registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "ruby_llm"
+require_relative "deprecation_cache"
 
 module Aidp
   module Harness
@@ -26,6 +27,11 @@ module Aidp
         "openrouter" => "openrouter"
       }.freeze
 
+      # Get deprecation cache instance (lazy loaded)
+      def deprecation_cache
+        @deprecation_cache ||= Aidp::Harness::DeprecationCache.new
+      end
+
       # Tier classification based on model characteristics
       # These are heuristics since ruby_llm doesn't classify tiers
       TIER_CLASSIFICATION = {
@@ -59,7 +65,8 @@ module Aidp
         standard: ->(model) { true }
       }.freeze
 
-      def initialize
+      def initialize(deprecation_cache: nil)
+        @deprecation_cache = deprecation_cache
         @models = RubyLLM::Models.instance.instance_variable_get(:@models)
         @index_by_id = @models.to_h { |m| [m.id, m] }
 
@@ -73,11 +80,18 @@ module Aidp
       #
       # @param model_name [String] Model name (e.g., "claude-3-5-haiku" or "claude-3-5-haiku-20241022")
       # @param provider [String, nil] Optional AIDP provider filter
+      # @param skip_deprecated [Boolean] Skip deprecated models (default: true)
       # @return [String, nil] Canonical model ID for API calls, or nil if not found
-      def resolve_model(model_name, provider: nil)
+      def resolve_model(model_name, provider: nil, skip_deprecated: true)
         # Map AIDP provider to registry provider if filtering
         registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
 
+        # Check if model is deprecated
+        if skip_deprecated && model_deprecated?(model_name, registry_provider)
+          Aidp.log_warn("ruby_llm_registry", "skipping deprecated model", model: model_name, provider: provider)
+          return nil
+        end
+
         # Try exact match first
         model = @index_by_id[model_name]
         return model.id if model && (registry_provider.nil? || model.provider.to_s == registry_provider)
@@ -88,13 +102,20 @@ module Aidp
           # Filter by provider if specified
           family_models = family_models.select { |m| m.provider.to_s == registry_provider } if registry_provider
 
+          # Filter out deprecated models if requested
+          if skip_deprecated
+            family_models = family_models.reject do |m|
+              deprecation_cache.deprecated?(provider: registry_provider, model_id: m.id.to_s)
+            end
+          end
+
           # Return the latest version (first non-"latest" model, or the latest one)
           model = family_models.reject { |m| m.id.to_s.include?("-latest") }.first || family_models.first
           return model.id if model
         end
 
         # Try fuzzy matching for common patterns
-        fuzzy_match = find_fuzzy_match(model_name, registry_provider)
+        fuzzy_match = find_fuzzy_match(model_name, registry_provider, skip_deprecated: skip_deprecated)
         return fuzzy_match.id if fuzzy_match
 
         Aidp.log_warn("ruby_llm_registry", "model not found", model: model_name, provider: provider)
@@ -124,8 +145,9 @@ module Aidp
       #
       # @param tier [String, Symbol] The tier name (mini, standard, advanced)
       # @param provider [String, nil] Optional AIDP provider filter
+      # @param skip_deprecated [Boolean] Skip deprecated models (default: true)
       # @return [Array<String>] List of model IDs for the tier
-      def models_for_tier(tier, provider: nil)
+      def models_for_tier(tier, provider: nil, skip_deprecated: true)
         tier_sym = tier.to_sym
         classifier = TIER_CLASSIFICATION[tier_sym]
 
@@ -152,6 +174,11 @@ module Aidp
           end
         end
 
+        # Filter out deprecated models if requested
+        if skip_deprecated
+          models.reject! { |m| deprecation_cache.deprecated?(provider: registry_provider, model_id: m.id.to_s) }
+        end
+
         model_ids = models.map(&:id).uniq
         Aidp.log_debug("ruby_llm_registry", "found models for tier",
           tier: tier, provider: provider, count: model_ids.size)
@@ -191,6 +218,51 @@ module Aidp
         Aidp.log_info("ruby_llm_registry", "refreshed", models: @models.size)
       end
 
+      # Check if a model is deprecated
+      # @param model_id [String] The model ID to check
+      # @param provider [String, nil] The provider name (registry format)
+      # @return [Boolean] True if model is deprecated
+      def model_deprecated?(model_id, provider = nil)
+        return false unless provider
+
+        deprecation_cache.deprecated?(provider: provider, model_id: model_id.to_s)
+      end
+
+      # Find replacement for a deprecated model
+      # Returns the latest non-deprecated model in the same family/tier
+      # @param deprecated_model [String] The deprecated model ID
+      # @param provider [String, nil] The provider name (AIDP format)
+      # @return [String, nil] Replacement model ID or nil
+      def find_replacement_model(deprecated_model, provider: nil)
+        registry_provider = provider ? PROVIDER_NAME_MAPPING[provider] : nil
+        return nil unless registry_provider
+
+        # Determine tier of deprecated model
+        deprecated_info = @index_by_id[deprecated_model]
+        return nil unless deprecated_info
+
+        tier = classify_tier(deprecated_info)
+
+        # Get all non-deprecated models for this tier and provider
+        candidates = models_for_tier(tier, provider: provider, skip_deprecated: true)
+
+        # Prefer models in the same family (e.g., both "sonnet")
+        family_keyword = extract_family_keyword(deprecated_model)
+        same_family = candidates.select { |m| m.to_s.include?(family_keyword) } if family_keyword
+
+        # Return first match from same family, or first candidate overall
+        replacement = same_family&.first || candidates.first
+
+        if replacement
+          Aidp.log_info("ruby_llm_registry", "found replacement",
+            deprecated: deprecated_model,
+            replacement: replacement,
+            tier: tier)
+        end
+
+        replacement
+      end
+
       private
 
       # Build an index mapping family names to model objects
@@ -208,13 +280,18 @@ module Aidp
       end
 
       # Find a model by fuzzy matching
-      def find_fuzzy_match(model_name, provider)
+      def find_fuzzy_match(model_name, provider, skip_deprecated: true)
         # Normalize the search term
         normalized = model_name.downcase.gsub(/[^a-z0-9]/, "")
 
         candidates = @models.select do |m|
           next false if provider && m.provider.to_s != provider
 
+          # Skip deprecated if requested
+          if skip_deprecated
+            next false if deprecation_cache.deprecated?(provider: provider, model_id: m.id.to_s)
+          end
+
           # Check if model ID contains the search term
           m.id.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized) ||
             m.name.to_s.downcase.gsub(/[^a-z0-9]/, "").include?(normalized)
@@ -224,6 +301,17 @@ module Aidp
         candidates.min_by { |m| m.id.to_s.length }
       end
 
+      # Extract family keyword from model ID (e.g., "sonnet", "haiku", "opus")
+      def extract_family_keyword(model_id)
+        case model_id.to_s
+        when /sonnet/i then "sonnet"
+        when /haiku/i then "haiku"
+        when /opus/i then "opus"
+        when /gpt-4/i then "gpt-4"
+        when /gpt-3/i then "gpt-3"
+        end
+      end
+
       # Extract capabilities from model info
       def extract_capabilities(model)
         caps = []

data/lib/aidp/harness/thinking_depth_manager.rb

@@ -160,11 +160,53 @@ module Aidp
           if configured_models.any?
             # Use first configured model for this provider and tier
             model_name = configured_models.first
-            Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
-              tier: tier,
-              provider: provider,
-              model: model_name)
-            return [provider, model_name, {}]
+
+            # Check if model is deprecated and try to upgrade
+            require_relative "ruby_llm_registry" unless defined?(Aidp::Harness::RubyLLMRegistry)
+            llm_registry = Aidp::Harness::RubyLLMRegistry.new
+
+            if llm_registry.model_deprecated?(model_name, provider)
+              Aidp.log_warn("thinking_depth_manager", "Configured model is deprecated",
+                tier: tier,
+                provider: provider,
+                model: model_name)
+
+              # Try to find replacement
+              replacement = llm_registry.find_replacement_model(model_name, provider: provider)
+              if replacement
+                Aidp.log_info("thinking_depth_manager", "Auto-upgrading to non-deprecated model",
+                  tier: tier,
+                  provider: provider,
+                  old_model: model_name,
+                  new_model: replacement)
+                model_name = replacement
+              else
+                # Try next model in config list
+                non_deprecated = configured_models.find { |m| !llm_registry.model_deprecated?(m, provider) }
+                if non_deprecated
+                  Aidp.log_info("thinking_depth_manager", "Using alternate configured model",
+                    tier: tier,
+                    provider: provider,
+                    skipped: model_name,
+                    selected: non_deprecated)
+                  model_name = non_deprecated
+                else
+                  Aidp.log_warn("thinking_depth_manager", "All configured models deprecated, falling back to catalog",
+                    tier: tier,
+                    provider: provider)
+                  # Fall through to catalog selection
+                  model_name = nil
+                end
+              end
+            end
+
+            if model_name
+              Aidp.log_debug("thinking_depth_manager", "Selected model from user config",
+                tier: tier,
+                provider: provider,
+                model: model_name)
+              return [provider, model_name, {}]
+            end
           end
 
           # Provider specified but has no models for this tier in config

data/lib/aidp/providers/anthropic.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "base"
 require_relative "../debug_mixin"
+require_relative "../harness/deprecation_cache"
 
 module Aidp
   module Providers
@@ -14,6 +15,11 @@ module Aidp
       # Model name pattern for Anthropic Claude models
       MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
 
+      # Get deprecation cache instance (lazy loaded)
+      def self.deprecation_cache
+        @deprecation_cache ||= Aidp::Harness::DeprecationCache.new
+      end
+
       def self.available?
         !!Aidp::Util.which("claude")
       end
@@ -212,6 +218,56 @@ module Aidp
         ["--dangerously-skip-permissions"]
       end
 
+      # Classify provider error using string matching
+      #
+      # ZFC EXCEPTION: Cannot use AI to classify provider errors because:
+      # 1. The failing provider IS the AI we'd use for classification (circular dependency)
+      # 2. Provider may be rate-limited, down, or misconfigured
+      # 3. Error classification must work even when AI unavailable
+      #
+      # This is a legitimate exception to ZFC principles per LLM_STYLE_GUIDE:
+      # "Structural safety checks" are allowed in code when AI cannot be used.
+      #
+      # @param error_message [String] The error message to classify
+      # @return [Hash] Classification result with :type, :is_deprecation, :is_rate_limit, :confidence
+      def self.classify_provider_error(error_message)
+        msg_lower = error_message.downcase
+
+        # Use simple string.include? checks (not regex) to avoid ReDoS vulnerabilities
+        is_rate_limit = msg_lower.include?("rate limit") || msg_lower.include?("session limit")
+        is_deprecation = msg_lower.include?("deprecat") || msg_lower.include?("end-of-life")
+        is_auth_error = msg_lower.include?("auth") && (msg_lower.include?("expired") || msg_lower.include?("invalid"))
+
+        # Determine primary type
+        type = if is_rate_limit
+          "rate_limit"
+        elsif is_deprecation
+          "deprecation"
+        elsif is_auth_error
+          "auth_error"
+        else
+          "other"
+        end
+
+        Aidp.log_debug("anthropic", "Provider error classification",
+          type: type,
+          is_rate_limit: is_rate_limit,
+          is_deprecation: is_deprecation,
+          is_auth_error: is_auth_error)
+
+        {
+          type: type,
+          is_rate_limit: is_rate_limit,
+          is_deprecation: is_deprecation,
+          is_auth_error: is_auth_error,
+          confidence: 0.85, # Good confidence for clear error messages
+          reasoning: "Pattern-based classification (ZFC exception: circular dependency)"
+        }
+      end
+
+      # Error patterns for classify_error method (legacy support)
+      # NOTE: ZFC-based classification preferred - see classify_error_with_zfc
+      # These patterns serve as fallback when ZFC is unavailable
       def error_patterns
         {
           rate_limited: [
@@ -247,14 +303,72 @@ module Aidp
             /not.*found/i,
             /404/,
             /bad.*request/i,
-            /400/
+            /400/,
+            /model.*deprecated/i,
+            /end-of-life/i
           ]
         }
       end
 
+      # Check if a model is deprecated and return replacement
+      # @param model_name [String] The model name to check
+      # @return [String, nil] Replacement model name if deprecated, nil otherwise
+      def self.check_model_deprecation(model_name)
+        deprecation_cache.replacement_for(provider: "anthropic", model_id: model_name)
+      end
+
+      # Find replacement model for deprecated one using RubyLLM registry
+      # @param deprecated_model [String] The deprecated model name
+      # @param provider_name [String] Provider name for registry lookup
+      # @return [String, nil] Latest model in the same family, or configured replacement
+      def self.find_replacement_model(deprecated_model, provider_name: "anthropic")
+        # First check the deprecation cache for explicit replacement
+        replacement = deprecation_cache.replacement_for(provider: provider_name, model_id: deprecated_model)
+        return replacement if replacement
+
+        # Try to find latest model in same family using registry
+        require_relative "../harness/ruby_llm_registry" unless defined?(Aidp::Harness::RubyLLMRegistry)
+
+        begin
+          registry = Aidp::Harness::RubyLLMRegistry.new
+
+          # Search for non-deprecated models in the same family
+          # Prefer models without "latest" suffix, sorted by ID (newer dates first)
+          models = registry.models_for_provider(provider_name)
+          candidates = models.select { |m| m.include?("sonnet") && !deprecation_cache.deprecated?(provider: provider_name, model_id: m) }
+
+          # Prioritize: versioned models over -latest, newer versions first
+          versioned = candidates.reject { |m| m.end_with?("-latest") }.sort.reverse
+          latest_models = candidates.select { |m| m.end_with?("-latest") }
+
+          replacement = versioned.first || latest_models.first
+
+          if replacement
+            Aidp.log_info("anthropic", "Found replacement model",
+              deprecated: deprecated_model,
+              replacement: replacement)
+          end
+
+          replacement
+        rescue => e
+          Aidp.log_error("anthropic", "Failed to find replacement model",
+            deprecated: deprecated_model,
+            error: e.message)
+          nil
+        end
+      end
+
       def send_message(prompt:, session: nil, options: {})
         raise "claude CLI not available" unless self.class.available?
 
+        # Check if current model is deprecated and warn
+        if @model && (replacement = self.class.check_model_deprecation(@model))
+          Aidp.log_warn("anthropic", "Using deprecated model",
+            current: @model,
+            replacement: replacement)
+          debug_log("⚠️  Model #{@model} is deprecated. Consider upgrading to #{replacement}", level: :warn)
+        end
+
         # Smart timeout calculation with tier awareness
         timeout_seconds = calculate_timeout(options)
 
@@ -287,15 +401,72 @@ module Aidp
             # Detect issues in stdout/stderr (Claude sometimes prints to stdout)
             combined = [result.out, result.err].compact.join("\n")
 
-            # Check for rate limit (Session limit reached)
-            if combined.match?(/session limit reached/i)
+            # Classify provider error using pattern matching
+            # ZFC EXCEPTION: Cannot use AI to classify provider's own errors (circular dependency)
+            error_classification = self.class.classify_provider_error(combined)
+
+            Aidp.log_debug("anthropic_provider", "error_classified",
+              exit_code: result.exit_status,
+              type: error_classification[:type],
+              confidence: error_classification[:confidence])            # Check for rate limit
+            if error_classification[:is_rate_limit]
               Aidp.log_debug("anthropic_provider", "rate_limit_detected",
                 exit_code: result.exit_status,
+                confidence: error_classification[:confidence],
                 message: combined)
               notify_rate_limit(combined)
               error_message = "Rate limit reached for Claude CLI.\n#{combined}"
-              debug_error(StandardError.new(error_message), {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
-              raise error_message
+              error = RuntimeError.new(error_message)
+              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+              raise error
+            end
+
+            # Check for model deprecation
+            if error_classification[:is_deprecation]
+              deprecated_model = @model
+              Aidp.log_error("anthropic", "Model deprecation detected",
+                model: deprecated_model,
+                message: combined)
+
+              # Try to find replacement
+              replacement = deprecated_model ? self.class.find_replacement_model(deprecated_model) : nil
+
+              # Record deprecation in cache for future runs
+              if replacement
+                self.class.deprecation_cache.add_deprecated_model(
+                  provider: "anthropic",
+                  model_id: deprecated_model,
+                  replacement: replacement,
+                  reason: combined.lines.first&.strip || "Model deprecated"
+                )
+
+                Aidp.log_info("anthropic", "Auto-upgrading to non-deprecated model",
+                  old_model: deprecated_model,
+                  new_model: replacement)
+                debug_log("🔄 Upgrading from deprecated model #{deprecated_model} to #{replacement}", level: :info)
+
+                # Update model and retry
+                @model = replacement
+
+                # Retry with new model
+                debug_log("🔄 Retrying with upgraded model: #{replacement}", level: :info)
+                return send_message(prompt: prompt, session: session, options: options)
+              else
+                # Record deprecation even without replacement
+                if deprecated_model
+                  self.class.deprecation_cache.add_deprecated_model(
+                    provider: "anthropic",
+                    model_id: deprecated_model,
+                    replacement: nil,
+                    reason: combined.lines.first&.strip || "Model deprecated"
+                  )
+                end
+
+                error_message = "Model '#{deprecated_model}' is deprecated and no replacement found.\n#{combined}"
+                error = RuntimeError.new(error_message)
+                debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+                raise error
+              end
             end
 
             # Check for auth issues
@@ -303,12 +474,15 @@ module Aidp
               error_message = "Authentication error from Claude CLI: token expired or invalid.\n" \
                               "Run 'claude /login' or refresh credentials.\n" \
                               "Note: Model discovery requires valid authentication."
-              debug_error(StandardError.new(error_message), {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
-              raise error_message
+              error = RuntimeError.new(error_message)
+              debug_error(error, {exit_code: result.exit_status, stdout: result.out, stderr: result.err})
+              raise error
             end
 
-            debug_error(StandardError.new("claude failed"), {exit_code: result.exit_status, stderr: result.err})
-            raise "claude failed with exit code #{result.exit_status}: #{result.err}"
+            error_message = "claude failed with exit code #{result.exit_status}: #{result.err}"
+            error = RuntimeError.new(error_message)
+            debug_error(error, {exit_code: result.exit_status, stderr: result.err})
+            raise error
           end
         rescue => e
           debug_error(e, {provider: "claude", prompt_length: prompt.length})

data/lib/aidp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aidp
-  VERSION = "0.29.0"
+  VERSION = "0.30.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aidp
 version: !ruby/object:Gem::Version
-  version: 0.29.0
+  version: 0.30.0
 platform: ruby
 authors:
 - Bart Agapinan
@@ -324,6 +324,7 @@ files:
 - lib/aidp/harness/config_schema.rb
 - lib/aidp/harness/config_validator.rb
 - lib/aidp/harness/configuration.rb
+- lib/aidp/harness/deprecation_cache.rb
 - lib/aidp/harness/enhanced_runner.rb
 - lib/aidp/harness/error_handler.rb
 - lib/aidp/harness/filter_strategy.rb