rubyn-code 0.4.0 → 0.5.1

data/lib/rubyn_code/cli/setup.rb

@@ -95,6 +95,19 @@ module RubynCode
           #
           # To regenerate: rubyn-code --setup
           # To remove:     rm #{path}
+          if [ ! -x "#{pinned_ruby}" ] || [ ! -f "#{gem_wrapper}" ]; then
+            echo "rubyn-code: launcher target missing" >&2
+            [ ! -x "#{pinned_ruby}" ] && echo "  pinned Ruby: #{pinned_ruby}" >&2
+            [ ! -f "#{gem_wrapper}" ] && echo "  gem wrapper: #{gem_wrapper}" >&2
+            echo >&2
+            echo "The Ruby that 'rubyn-code --setup' was pinned against (or the gem" >&2
+            echo "itself) was removed. To recover under your current Ruby:" >&2
+            echo >&2
+            echo "  rm '$0'" >&2
+            echo "  gem install rubyn-code" >&2
+            echo "  rubyn-code --setup" >&2
+            exit 127
+          fi
           exec "#{pinned_ruby}" "#{gem_wrapper}" "$@"
         BASH
       end

data/lib/rubyn_code/config/defaults.rb

@@ -31,6 +31,8 @@ module RubynCode
       POLL_INTERVAL = 5
       IDLE_TIMEOUT = 60
 
+      SKILLS_AUTOLOAD = true
+
       SESSION_BUDGET_USD = 5.00
       DAILY_BUDGET_USD = 10.00
 

data/lib/rubyn_code/config/settings.rb

@@ -16,6 +16,7 @@ module RubynCode
         session_budget_usd daily_budget_usd
         oauth_client_id oauth_redirect_uri oauth_authorize_url
         oauth_token_url oauth_scopes
+        skills_autoload
       ].freeze
 
       DEFAULT_MAP = {
@@ -35,7 +36,8 @@ module RubynCode
         oauth_redirect_uri: Defaults::OAUTH_REDIRECT_URI,
         oauth_authorize_url: Defaults::OAUTH_AUTHORIZE_URL,
         oauth_token_url: Defaults::OAUTH_TOKEN_URL,
-        oauth_scopes: Defaults::OAUTH_SCOPES
+        oauth_scopes: Defaults::OAUTH_SCOPES,
+        skills_autoload: Defaults::SKILLS_AUTOLOAD
       }.freeze
 
       attr_reader :config_path, :data
@@ -160,7 +162,8 @@ module RubynCode
 
       # Backfills missing 'models' keys into existing provider configs.
       # Never overwrites user-set values — only adds what's missing.
-      def backfill_provider_models! # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- iterates providers with guard clauses
+      # -- iterates providers with guard clauses
+      def backfill_provider_models!
         providers = @data['providers']
         return unless providers.is_a?(Hash)
 

data/lib/rubyn_code/context/context_budget.rb

@@ -130,7 +130,8 @@ module RubynCode
         end
       end
 
-      def process_signature_line(line, signatures, indent_stack) # rubocop:disable Metrics/AbcSize -- signature extraction dispatch
+      # -- signature extraction dispatch
+      def process_signature_line(line, signatures, indent_stack)
         stripped = line.strip
         if signature_line?(stripped)
           signatures << line

data/lib/rubyn_code/context/manager.rb

@@ -74,11 +74,9 @@ module RubynCode
       MICRO_COMPACT_RATIO_UNCACHED = 0.5
 
       def check_compaction!(conversation)
-        # Guard: skip if compaction already ran this turn
+        # Guard: skip if compaction already succeeded this turn
         return if @last_compaction_turn == @current_turn
 
-        @last_compaction_turn = @current_turn
-
         messages = conversation.messages
 
         # Step 1: Zero-cost micro-compact — but only when we're approaching
@@ -93,6 +91,7 @@ module RubynCode
         collapsed = ContextCollapse.call(messages, threshold: @threshold)
         if collapsed
           apply_compacted_messages(conversation, collapsed)
+          @last_compaction_turn = @current_turn
           return
         end
 
@@ -102,6 +101,7 @@ module RubynCode
         compactor = Compactor.new(llm_client: @llm_client, threshold: @threshold)
         new_messages = compactor.auto_compact!(messages)
         apply_compacted_messages(conversation, new_messages)
+        @last_compaction_turn = @current_turn
       end
 
       # Resets cumulative token counters to zero.

data/lib/rubyn_code/ide/handlers/plan_interview_answer_handler.rb

@@ -0,0 +1,65 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/answer" — feeds the user's answer into the
+      # active InterviewSession, emits the next question OR the final plan
+      # via notifications, and returns an empty ack to the extension.
+      class PlanInterviewAnswerHandler
+        SESSION_NOT_FOUND_CODE = -32_011
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id  = params['sessionId'].to_s
+          question_id = params['questionId'].to_s
+          answer      = params['answer'].to_s
+
+          session = @server.lookup_interview_session(session_id)
+          unless session
+            raise Protocol::JsonRpcError.new(SESSION_NOT_FOUND_CODE,
+                                              "Unknown interview session: #{session_id}")
+          end
+
+          outcome = session.answer(question_id, answer)
+          emit_outcome(session, outcome)
+          {}
+        rescue Megaplan::InterviewSession::InvalidAnswerError => e
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, e.message)
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewAnswerHandler] interview failed: #{e.message}"
+          @server.notify('plan/interview/error', {
+            'sessionId' => params['sessionId'],
+            'message' => e.message
+          })
+          @server.drop_interview_session(params['sessionId'].to_s)
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+              'sessionId' => session.session_id,
+              'questionId' => outcome.id,
+              'text' => outcome.text,
+              'options' => outcome.options
+            })
+          else
+            @server.notify('plan/interview/done', {
+              'sessionId' => session.session_id,
+              'plan' => outcome
+            })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_interview_cancel_handler.rb

@@ -0,0 +1,22 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/cancel" — drops the named InterviewSession.
+      # Notification handler (no id), so it never sends a response. Unknown
+      # sessionIds are no-ops; the extension treats cancel as best-effort.
+      class PlanInterviewCancelHandler
+        def initialize(server)
+          @server = server
+        end
+
+        def call(params)
+          session_id = params['sessionId'].to_s
+          @server.drop_interview_session(session_id)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_interview_start_handler.rb

@@ -0,0 +1,53 @@
+  # frozen_string_literal: true
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles "plan/interview/start" — kicks off a megaplan interview
+      # session. Creates the InterviewSession, fires the first LLM turn,
+      # and emits either a plan/interview/question or plan/interview/done
+      # notification before returning the new sessionId to the extension.
+      class PlanInterviewStartHandler
+        INVALID_INTERVIEW_CODE = -32_010
+
+        def initialize(server, factory: nil)
+          @server = server
+          @factory = factory || ->(workspace_path:) {
+            Megaplan::InterviewSession.new(workspace_path: workspace_path)
+          }
+        end
+
+        def call(_params)
+          session = @factory.call(workspace_path: @server.workspace_path || Dir.pwd)
+          @server.register_interview_session(session)
+          outcome = session.start
+          emit_outcome(session, outcome)
+          { 'sessionId' => session.session_id }
+        rescue Megaplan::InterviewSession::MalformedResponseError,
+               Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanInterviewStartHandler] interview failed: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_INTERVIEW_CODE, e.message)
+        end
+
+        private
+
+        def emit_outcome(session, outcome)
+          if outcome.is_a?(Megaplan::InterviewSession::Question)
+            @server.notify('plan/interview/question', {
+              'sessionId' => session.session_id,
+              'questionId' => outcome.id,
+              'text' => outcome.text,
+              'options' => outcome.options
+            })
+          else
+            @server.notify('plan/interview/done', {
+              'sessionId' => session.session_id,
+              'plan' => outcome
+            })
+            @server.drop_interview_session(session.session_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/plan_propose_handler.rb

@@ -0,0 +1,41 @@
+  # frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "plan/propose" JSON-RPC request.
+      #
+      # Synchronous: blocks until the LLM returns a structured plan or
+      # raises. The extension shows a progress spinner during the call;
+      # plan generation typically takes 5-30s.
+      #
+      # Response shape mirrors what the extension's PlanManager.toPlan
+      # expects: { slug, feature, phases: [{ number, name, slug, summary,
+      # requirements_md, design_md, tasks_md }] }.
+      class PlanProposeHandler
+        # JSON-RPC error code: a clear signal to the extension that the
+        # LLM produced an unparseable / malformed plan_proposal. The
+        # extension surfaces this with the actual error message.
+        INVALID_PROPOSAL_CODE = -32_001
+
+        def initialize(server, proposer: nil)
+          @server = server
+          @proposer = proposer
+        end
+
+        def call(params)
+          feature = params['feature'].to_s.strip
+          raise Protocol::JsonRpcError.new(Protocol::INVALID_PARAMS, 'feature is required') if feature.empty?
+
+          proposer = @proposer || Megaplan::PlanProposer.new
+          proposer.propose(feature)
+        rescue Megaplan::PlanProposer::InvalidProposalError => e
+          warn "[PlanProposeHandler] invalid proposal: #{e.message}"
+          raise Protocol::JsonRpcError.new(INVALID_PROPOSAL_CODE, e.message)
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/prompt_handler.rb

@@ -62,7 +62,8 @@ module RubynCode
 
         private
 
-        def run_agent(session_id, text, context) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- orchestrates agent lifecycle with notifications
+        # -- orchestrates agent lifecycle with notifications
+        def run_agent(session_id, text, context)
           @server.notify('agent/status', {
                            'sessionId' => session_id,
                            'status' => 'thinking'
@@ -165,7 +166,8 @@ module RubynCode
         # Install a ToolOutput adapter on the server so AcceptEdit /
         # ApproveToolUse handlers can route responses back to this session.
         def build_tool_output_adapter
-          adapter = IDE::Adapters::ToolOutput.new(@server, permission_mode: @server.permission_mode, hook_runner: build_ide_hook_runner)
+          adapter = IDE::Adapters::ToolOutput.new(@server, permission_mode: @server.permission_mode,
+                                                           hook_runner: build_ide_hook_runner)
           @server.tool_output_adapter = adapter
           adapter
         end
@@ -190,7 +192,8 @@ module RubynCode
           Hooks::Runner.new(registry: registry)
         end
 
-        def build_enriched_input(text, context) # rubocop:disable Metrics/AbcSize -- assembles context parts from multiple optional fields
+        # -- assembles context parts from multiple optional fields
+        def build_enriched_input(text, context)
           parts = []
 
           parts << "[Active file: #{context['activeFile']}]" if context['activeFile']

data/lib/rubyn_code/ide/handlers/recover_ci_handler.rb

@@ -0,0 +1,132 @@
+  # frozen_string_literal: true
+
+require 'securerandom'
+
+module RubynCode
+  module IDE
+    module Handlers
+      # Handles the "recover_ci" JSON-RPC request.
+      #
+      # Takes the recovery context the extension packaged (failing log,
+      # phase docs, branch, attempt counts) and runs the agent against
+      # it. Returns the recovery_outcome { kind, commit_sha?, summary? }.
+      #
+      # The handler spawns the actual agent work in a background thread
+      # so the JSON-RPC reply can include a sessionId immediately. The
+      # extension watches the session via the existing agent/status
+      # notifications + a terminal recovery/outcome notification carrying
+      # the structured result.
+      class RecoverCiHandler
+        def initialize(server, recovery: nil)
+          @server = server
+          @recovery = recovery
+        end
+
+        def call(params)
+          context = normalize_params(params)
+          return error_response('context required') if context.nil?
+
+          session_id = params['sessionId'] || SecureRandom.uuid
+          Thread.new do
+            run_recovery(session_id, context)
+          end
+          { 'accepted' => true, 'sessionId' => session_id }
+        end
+
+        private
+
+        def run_recovery(session_id, context)
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'recovering',
+                           'phaseNumber' => context['phase_number'],
+                           'attemptNumber' => context['attempt_number']
+                         })
+
+          recovery = @recovery || Megaplan::CiRecovery.new(
+            agent_invoker: build_invoker(session_id)
+          )
+          outcome = recovery.recover(context)
+
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => outcome['kind'],
+                           'commitSha' => outcome['commit_sha'],
+                           'summary' => outcome['summary']
+                         })
+
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'done',
+                           'summary' => outcome['summary']
+                         })
+        rescue StandardError => e
+          warn "[RecoverCiHandler] error: #{e.message}"
+          @server.notify('recovery/outcome', {
+                           'sessionId' => session_id,
+                           'planId' => context['plan_id'],
+                           'phaseNumber' => context['phase_number'],
+                           'kind' => 'errored',
+                           'summary' => e.message
+                         })
+          @server.notify('agent/status', {
+                           'sessionId' => session_id,
+                           'status' => 'error',
+                           'error' => e.message
+                         })
+        end
+
+        # Build an agent invoker that routes the recovery prompt through
+        # the same Agent::Loop the existing PromptHandler uses, but with
+        # the streaming text wired back as agent/status notifications
+        # tagged with the recovery session id.
+        def build_invoker(session_id)
+          lambda do |prompt, _context|
+            llm_client = LLM::Client.new
+            response = llm_client.chat(
+              messages: [{ role: 'user', content: prompt }],
+              on_text: ->(text) {
+                @server.notify('stream/text', {
+                                 'sessionId' => session_id,
+                                 'text' => text,
+                                 'final' => false
+                               })
+              }
+            )
+            response.is_a?(Hash) ? response : { 'text' => response.to_s }
+          end
+        end
+
+        def normalize_params(params)
+          return nil unless params.is_a?(Hash)
+
+          # Accept both snake_case and camelCase keys — the extension
+          # produces camelCase, but the LLM-side service uses snake_case
+          # internally. Normalize once at the boundary.
+          mapping = {
+            'planId' => 'plan_id',
+            'phaseNumber' => 'phase_number',
+            'prNumber' => 'pr_number',
+            'failingCheckName' => 'failing_check_name',
+            'fullLog' => 'full_log',
+            'trimmedLog' => 'trimmed_log',
+            'commitSha' => 'commit_sha',
+            'attemptNumber' => 'attempt_number',
+            'maxAttempts' => 'max_attempts'
+          }
+          out = params.dup
+          mapping.each do |camel, snake|
+            out[snake] = out.delete(camel) if out.key?(camel) && !out.key?(snake)
+          end
+          out
+        end
+
+        def error_response(message, code: -32_602)
+          { 'error' => { 'code' => code, 'message' => message } }
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/ide/handlers/review_handler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../skills/pack_context'
+
 module RubynCode
   module IDE
     module Handlers
@@ -31,15 +33,16 @@ module RubynCode
 
         private
 
-        def run_review(session_id, base_branch, focus) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- review lifecycle with finding notifications
+        def run_review(session_id, base_branch, focus) # rubocop:disable Metrics/MethodLength -- review lifecycle with finding notifications
           @server.notify('agent/status', {
                            'sessionId' => session_id,
                            'status' => 'reviewing'
                          })
 
           workspace = @server.workspace_path || Dir.pwd
+          pack_context = build_pack_context(workspace)
           review_tool = Tools::ReviewPr.new(project_root: workspace)
-          result = review_tool.execute(base_branch: base_branch, focus: focus)
+          result = review_tool.execute(base_branch: base_branch, focus: focus, pack_context: pack_context)
 
           # Parse the review output into individual findings and emit them
           findings = extract_findings(result)
@@ -68,6 +71,20 @@ module RubynCode
                          })
         end
 
+        # Fetch skill pack context for gems detected in the repo's Gemfile.
+        # Returns nil on any failure — pack context is best-effort and must never
+        # block the review from running.
+        #
+        # @param workspace [String] absolute path to the repository
+        # @return [String, nil] formatted context block or nil
+        def build_pack_context(workspace)
+          context = Skills::PackContext.for_repo(project_root: workspace)
+          block = context.build_context_block
+          block.empty? ? nil : block
+        rescue StandardError
+          nil
+        end
+
         def extract_findings(review_text)
           return [] unless review_text.is_a?(String)
 

data/lib/rubyn_code/ide/handlers.rb

@@ -14,6 +14,11 @@ require_relative 'handlers/session_reset_handler'
 require_relative 'handlers/session_list_handler'
 require_relative 'handlers/session_resume_handler'
 require_relative 'handlers/session_fork_handler'
+require_relative 'handlers/plan_propose_handler'
+require_relative 'handlers/plan_interview_start_handler'
+require_relative 'handlers/plan_interview_answer_handler'
+require_relative 'handlers/plan_interview_cancel_handler'
+require_relative 'handlers/recover_ci_handler'
 
 module RubynCode
   module IDE
@@ -33,7 +38,12 @@ module RubynCode
         'session/reset' => SessionResetHandler,
         'session/list' => SessionListHandler,
         'session/resume' => SessionResumeHandler,
-        'session/fork' => SessionForkHandler
+        'session/fork' => SessionForkHandler,
+        'plan/propose' => PlanProposeHandler,
+        'plan/interview/start' => PlanInterviewStartHandler,
+        'plan/interview/answer' => PlanInterviewAnswerHandler,
+        'plan/interview/cancel' => PlanInterviewCancelHandler,
+        'recover_ci' => RecoverCiHandler
       }.freeze
 
       # Short name => method name mapping (for handler_instance lookups).
@@ -51,7 +61,12 @@ module RubynCode
         session_reset: 'session/reset',
         session_list: 'session/list',
         session_resume: 'session/resume',
-        session_fork: 'session/fork'
+        session_fork: 'session/fork',
+        plan_propose: 'plan/propose',
+        plan_interview_start: 'plan/interview/start',
+        plan_interview_answer: 'plan/interview/answer',
+        plan_interview_cancel: 'plan/interview/cancel',
+        recover_ci: 'recover_ci'
       }.freeze
 
       # Register all handlers on the given server instance.

data/lib/rubyn_code/ide/protocol.rb

@@ -21,11 +21,27 @@ module RubynCode
       SESSION_NOT_FOUND = -2
       BUDGET_EXCEEDED   = -3
 
+      # Raise from a handler to emit a JSON-RPC error response with a
+      # specific code. The dispatcher catches this and converts it to a
+      # proper `error` envelope — handlers don't have to know how to write
+      # to the wire. Use this instead of returning `{ 'error' => ... }` as
+      # the handler result, which the dispatcher would otherwise serialize
+      # as a successful `result` payload (the very bug this class fixes).
+      class JsonRpcError < StandardError
+        attr_reader :code
+
+        def initialize(code, message)
+          super(message)
+          @code = code
+        end
+      end
+
       module_function
 
       # Parse a JSON string into a request hash.
       # Returns either a valid request hash or an error response hash.
-      def parse(line) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- JSON-RPC validation checks
+      # -- JSON-RPC validation checks
+      def parse(line)
         begin
           data = JSON.parse(line)
         rescue JSON::ParserError

data/lib/rubyn_code/ide/server.rb

@@ -21,7 +21,7 @@ module RubynCode
                     :permission_mode
       attr_reader :ide_client
 
-      def initialize(permission_mode: :default, yolo: false)
+      def initialize(permission_mode: :default, yolo: false, workspace_path: nil)
         @permission_mode = yolo ? :bypass : permission_mode.to_sym
         @running = false
         @write_mutex = Mutex.new
@@ -33,10 +33,45 @@ module RubynCode
         @session_persistence = nil
         @tool_output_adapter = nil
         @ide_client = Client.new(self)
+        @interview_sessions = {}
+
+        apply_initial_workspace(workspace_path)
 
         Handlers.register_all(self)
       end
 
+      # ── Interview session registry ──────────────────────────────────
+      # Owned by the IDE Server so handlers can look up the same session
+      # across start / answer / cancel JSON-RPC calls.
+
+      def register_interview_session(session)
+        @interview_sessions[session.session_id] = session
+      end
+
+      def lookup_interview_session(session_id)
+        @interview_sessions[session_id]
+      end
+
+      def drop_interview_session(session_id)
+        @interview_sessions.delete(session_id)
+      end
+
+      # Adopt a workspace path supplied on the command line (--dir). Done
+      # before the `initialize` JSON-RPC handshake so tools that resolve
+      # their project_root at construction time don't fall back to Dir.pwd
+      # — which in some launch contexts (Docker, double-clicked VS Code on
+      # macOS) is something useless like `/app` or `/`.
+      def apply_initial_workspace(path)
+        return unless path && !path.empty?
+
+        if Dir.exist?(path)
+          Dir.chdir(path)
+          @workspace_path = path
+        else
+          warn "[IDE::Server] --dir path does not exist, ignoring: #{path}"
+        end
+      end
+
       # Backward-compatible reader: true when permission_mode is :bypass.
       def yolo
         @permission_mode == :bypass
@@ -107,6 +142,9 @@ module RubynCode
         end
 
         dispatch(msg)
+      rescue Protocol::JsonRpcError => e
+        id = msg.is_a?(Hash) ? msg['id'] : nil
+        write(Protocol.error(id, e.code, e.message)) if id
       rescue StandardError => e
         warn "[IDE::Server] error handling message: #{e.message}"
         warn e.backtrace&.first(5)&.join("\n")

data/lib/rubyn_code/index/codebase_index.rb

@@ -260,7 +260,8 @@ module RubynCode
         end
       end
 
-      def classify_node(file, type) # rubocop:disable Metrics/CyclomaticComplexity -- Rails directory mapping
+      # -- Rails directory mapping
+      def classify_node(file, type)
         return 'model' if file.include?('app/models/')
         return 'controller' if file.include?('app/controllers/')
         return 'service' if file.include?('app/services/')

data/lib/rubyn_code/learning/extractor.rb

@@ -82,7 +82,8 @@ module RubynCode
           messages.map { |m| format_turn(m) }.join("\n\n")
         end
 
-        def format_turn(msg) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- content polymorphism
+        # -- content polymorphism
+        def format_turn(msg)
           role = (msg[:role] || msg['role'] || 'unknown').capitalize
           content = msg[:content] || msg['content']
           text = if content.is_a?(Array)
@@ -121,7 +122,8 @@ module RubynCode
           )
         end
 
-        def parse_response(response) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- response parsing with multiple fallbacks
+        # -- response parsing with multiple fallbacks
+        def parse_response(response)
           return [] if response.nil?
 
           text = if response.respond_to?(:content)

data/lib/rubyn_code/llm/model_router.rb

@@ -84,7 +84,8 @@ module RubynCode
         # @param task_type [Symbol]
         # @param client [LLM::Client, nil] active client (for provider checks)
         # @return [Hash] { provider:, model: }
-        def resolve(task_type, client: nil) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- multi-source fallback chain
+        # -- multi-source fallback chain
+        def resolve(task_type, client: nil)
           tier = tier_for(task_type)
           active = active_provider