rubyn-code 0.4.0 → 0.5.0

data/lib/rubyn_code/cli/commands/list_skills.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class ListSkills < Base
+        def self.command_name = '/skills'
+        def self.description = 'List installed skills or browse the registry'
+
+        def execute(args, ctx)
+          if args.include?('--available')
+            list_available(ctx)
+          else
+            list_installed(ctx)
+          end
+        rescue Skills::RegistryError => e
+          ctx.renderer.error("Registry error: #{e.message}")
+        rescue StandardError => e
+          ctx.renderer.error("Skills error: #{e.message}")
+        end
+
+        private
+
+        def list_installed(ctx)
+          catalog = ctx.skill_loader.catalog
+          all_skills = catalog.available
+          buckets = partition_skills(all_skills, ctx)
+
+          ctx.renderer.info("Loaded skills (#{all_skills.size} total)")
+          puts
+
+          render_builtin(buckets[:builtin], catalog)
+          render_packs(buckets[:packs])
+          render_community(buckets[:community], buckets[:packs].any?)
+        end
+
+        def partition_skills(all_skills, ctx)
+          community_dir = File.join(ctx.project_root, '.rubyn-code', 'skills')
+          global_dir = File.join(Config::Defaults::HOME_DIR, 'skills')
+          pack_dir = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+
+          buckets = { builtin: [], community: [], packs: [] }
+          all_skills.each do |skill|
+            buckets[bucket_for(skill[:path].to_s, pack_dir, community_dir, global_dir)] << skill
+          end
+          buckets
+        end
+
+        def bucket_for(path, pack_dir, community_dir, global_dir)
+          return :packs if path.start_with?(pack_dir)
+          return :community if path.start_with?(community_dir) || path.start_with?(global_dir)
+
+          :builtin
+        end
+
+        def render_builtin(builtin, catalog)
+          puts "  Built-in (#{builtin.size})"
+          builtin.group_by { |s| category_from_path(s[:path], catalog.skills_dirs) }
+                 .sort_by { |cat, _| cat }
+                 .each do |cat, skills|
+            label = cat.empty? ? 'general' : cat
+            puts "    #{label}: #{skills.map { |s| s[:name] }.join(', ')}"
+          end
+        end
+
+        def render_packs(packs)
+          return if packs.empty?
+
+          puts
+          summary = packs.group_by { |s| pack_from_path(s[:path]) }
+                         .sort
+                         .map { |pack, skills| "#{pack} (#{skills.size})" }
+                         .join(', ')
+          puts "  Skill packs: #{summary}"
+        end
+
+        def render_community(community, packs_present)
+          if community.any?
+            puts
+            summary = community.group_by { |s| pack_from_path(s[:path]) }
+                               .map { |pack, skills| "#{pack} (#{skills.size})" }
+                               .join(', ')
+            puts "  Community: #{summary}"
+          elsif !packs_present
+            puts
+            puts '  Skill packs: none installed'
+            puts '  Run /skills --available to browse, or /install-skills <name> to install.'
+          end
+        end
+
+        def list_available(ctx) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- readable catalog display
+          client = Skills::RegistryClient.new
+          catalog_data = client.fetch_catalog
+          packs = catalog_data['packs'] || []
+
+          if packs.empty?
+            ctx.renderer.info('No packs available in the registry.')
+            return
+          end
+
+          installer = Skills::PackInstaller.new(
+            registry_client: client,
+            project_root: ctx.project_root
+          )
+
+          ctx.renderer.info("Available skill packs (#{packs.size})")
+          puts
+
+          # Group by category
+          by_category = packs.group_by { |p| p['category'] || 'other' }
+          by_category.sort_by { |cat, _| cat }.each do |category, cat_packs|
+            puts "  #{category.capitalize}"
+            cat_packs.each do |pack|
+              installed = installer.installed?(pack['name'])
+              marker = installed ? ' ✓' : ''
+              desc = pack['description']&.slice(0, 50) || ''
+              puts "    #{pack['name'].ljust(20)} #{desc}  (#{pack['skillCount']} skills)#{marker}"
+            end
+            puts
+          end
+
+          puts '  Install with: /install-skills <name>'
+        end
+
+        def category_from_path(path, skills_dirs)
+          skills_dirs.each do |dir|
+            expanded = File.expand_path(dir)
+            next unless path.to_s.start_with?(expanded)
+
+            relative = path.delete_prefix("#{expanded}/")
+            parts = relative.split('/')
+            return parts.size > 1 ? parts.first : ''
+          end
+          ''
+        end
+
+        def pack_from_path(path)
+          # Pack-style layouts: .rubyn-code/skills/<pack>/<file>.md
+          # or .rubyn-code/skill-packs/<pack>/<file>.md
+          parts = path.to_s.split('/')
+          idx = parts.rindex('skill-packs') || parts.rindex('skills')
+          return 'unknown' unless idx
+
+          parts[idx + 1] || 'unknown'
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/provider.rb

@@ -55,7 +55,8 @@ module RubynCode
           Auth::TokenStore.save_provider_key(name, opts[:key]) if opts[:key]
         end
 
-        def confirm_added(name, base_url, opts, ctx) # rubocop:disable Metrics/AbcSize -- sequential output lines
+        # -- sequential output lines
+        def confirm_added(name, base_url, opts, ctx)
           ctx.renderer.success("Provider '#{name}' added (#{opts[:api_format] || 'openai'} format)")
           ctx.renderer.info("  base_url: #{base_url}")
           ctx.renderer.info('  api_key: stored') if opts[:key]

data/lib/rubyn_code/cli/commands/remove_skills.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class RemoveSkills < Base
+        def self.command_name = '/remove-skills'
+        def self.description = 'Remove installed skill packs'
+
+        def execute(args, ctx)
+          if args.empty?
+            ctx.renderer.warning('Usage: /remove-skills <pack-name> [pack-name ...]')
+            return
+          end
+
+          pack_manager = RubynCode::Skills::PackManager.new
+
+          args.each { |name| remove_pack(name, pack_manager, ctx) }
+        end
+
+        private
+
+        def remove_pack(name, pack_manager, ctx)
+          unless pack_manager.installed?(name)
+            ctx.renderer.warning("Pack '#{name}' is not installed.")
+            return
+          end
+
+          pack_manager.remove(name)
+          ctx.renderer.info("Removed skill pack '#{name}'.")
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/commands/skill.rb

@@ -33,7 +33,8 @@ module RubynCode
           skills.each { |skill| puts "  /#{skill[:name]}: #{skill[:description]}" }
         end
 
-        def search_skills(term, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+        # -- readable sequential display logic
+        def search_skills(term, ctx)
           if term.nil? || term.strip.empty?
             ctx.renderer.warning('Usage: /skill search <term>')
             return
@@ -49,7 +50,8 @@ module RubynCode
           display_entries(results)
         end
 
-        def list_by_category(category, ctx) # rubocop:disable Metrics/AbcSize -- readable sequential display logic
+        # -- readable sequential display logic
+        def list_by_category(category, ctx)
           catalog = ctx.skill_loader.catalog
           return list_categories(catalog, ctx) if category.nil? || category.strip.empty?
 

data/lib/rubyn_code/cli/commands/skills.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module CLI
+    module Commands
+      class Skills < Base
+        def self.command_name = '/skills'
+        def self.description = 'List installed skill packs or browse the registry'
+
+        def execute(args, ctx)
+          case args.first
+          when 'search' then search_registry(args[1..].join(' '), ctx)
+          when 'available' then list_available(ctx)
+          when nil, 'list' then list_installed(ctx)
+          else
+            ctx.renderer.warning(
+              "Unknown subcommand '#{args.first}'. Try: /skills, /skills available, /skills search <term>"
+            )
+          end
+        rescue RubynCode::Skills::RegistryError => e
+          ctx.renderer.error(e.message)
+        end
+
+        private
+
+        def list_installed(ctx)
+          packs = RubynCode::Skills::PackManager.new.installed
+
+          if packs.empty?
+            ctx.renderer.info(
+              'No skill packs installed. Use /skills available to browse or /install-skills <name> to install.'
+            )
+            return
+          end
+
+          ctx.renderer.info("Installed skill packs (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_installed_pack(pack)}" }
+        end
+
+        def list_available(ctx)
+          ctx.renderer.info('Fetching available packs from registry...')
+          result = RubynCode::Skills::RegistryClient.new.fetch_catalog
+          packs = result[:data]
+          return ctx.renderer.info('No packs found in the registry.') unless valid_results?(packs)
+
+          pack_manager = RubynCode::Skills::PackManager.new
+          ctx.renderer.info("Available skill packs (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_available_pack(pack, pack_manager)}" }
+        end
+
+        def search_registry(term, ctx)
+          if term.nil? || term.strip.empty?
+            ctx.renderer.warning('Usage: /skills search <term>')
+            return
+          end
+
+          query = term.strip
+          ctx.renderer.info("Searching registry for '#{query}'...")
+          result = RubynCode::Skills::RegistryClient.new.search_packs(query)
+          packs = result[:data]
+
+          unless valid_results?(packs)
+            ctx.renderer.info("No packs found matching '#{query}'.")
+            return
+          end
+
+          ctx.renderer.info("Packs matching '#{query}' (#{packs.size}):")
+          packs.each { |pack| puts "  #{format_pack_line(pack)}" }
+        end
+
+        def valid_results?(results)
+          results.is_a?(Array) && !results.empty?
+        end
+
+        def format_installed_pack(pack)
+          version = pack[:version] ? " v#{pack[:version]}" : ''
+          desc = pack[:description].to_s.empty? ? '' : " — #{pack[:description]}"
+          "#{pack[:name]}#{version}#{desc}"
+        end
+
+        def format_available_pack(pack, pack_manager)
+          name = pack_name(pack)
+          installed = pack_manager.installed?(name) ? ' [installed]' : ''
+          "#{format_pack_line(pack)}#{installed}"
+        end
+
+        def format_pack_line(pack)
+          name = pack_name(pack)
+          desc = pack_description(pack)
+          label = desc.empty? ? '' : " — #{desc}"
+          "#{name}#{label}"
+        end
+
+        def pack_name(pack)
+          pack[:name] || pack['name']
+        end
+
+        def pack_description(pack)
+          (pack[:description] || pack['description']).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/cli/repl.rb

@@ -34,6 +34,7 @@ module RubynCode
 
         @renderer.welcome
         @version_check.notify
+        check_skill_suggestions!
 
         at_exit { shutdown! }
 
@@ -44,6 +45,14 @@ module RubynCode
 
       private
 
+      def check_skill_suggestions!
+        suggest = Skills::AutoSuggest.new(project_root: @project_root)
+        message = suggest.check
+        @renderer.info(message) if message
+      rescue StandardError
+        # Never block session start on suggestion failure
+      end
+
       def run_input_loop
         while @running
           begin
@@ -98,7 +107,8 @@ module RubynCode
         @stream_formatter&.feed(text)
       end
 
-      def handle_message(input) # rubocop:disable Metrics/AbcSize -- sequential steps with interrupt rescue
+      # -- sequential steps with interrupt rescue
+      def handle_message(input)
         @spinner.start
         @streaming_first_chunk = true
 

data/lib/rubyn_code/cli/repl_commands.rb

@@ -22,7 +22,8 @@ module RubynCode
           Commands::Spawn, Commands::Doctor, Commands::Tokens,
           Commands::Plan, Commands::ContextInfo, Commands::Diff,
           Commands::Model, Commands::NewSession, Commands::Mcp,
-          Commands::Provider
+          Commands::Provider, Commands::InstallSkills,
+          Commands::RemoveSkills, Commands::Skills
         ].each { |cmd| @command_registry.register(cmd) }
       end
 

data/lib/rubyn_code/cli/repl_setup.rb

@@ -42,9 +42,41 @@ module RubynCode
         @budget_enforcer = Observability::BudgetEnforcer.new(@db, session_id: current_session_id)
         @background_worker = Background::Worker.new(project_root: @project_root)
         @skill_loader = Skills::Loader.new(Skills::Catalog.new(skill_dirs))
+        @skill_matcher = build_skill_matcher
+        @web_skill_autoload = build_web_skill_autoload
         @session_persistence = Memory::SessionPersistence.new(@db)
       end
 
+      def build_skill_matcher
+        return nil unless skills_autoload_enabled?
+
+        Skills::Matcher.new(catalog: @skill_loader.catalog, project_root: @project_root)
+      end
+
+      def build_web_skill_autoload
+        return nil unless @skill_matcher && skills_autoload_enabled?
+
+        Skills::RegistryAutoload.new(
+          loader: @skill_loader,
+          matcher: @skill_matcher,
+          on_fetching: on_pack_fetching_callback
+        )
+      end
+
+      def skills_autoload_enabled?
+        Config::Settings.new.skills_autoload
+      rescue Config::Settings::LoadError
+        true
+      end
+
+      def on_skills_autoloaded_callback
+        ->(names) { @renderer.system_message("📚 Loaded: #{names.join(' · ')}") }
+      end
+
+      def on_pack_fetching_callback
+        ->(name) { @renderer.system_message("📥 Fetching skill pack '#{name}' from registry…") }
+      end
+
       def setup_executor_callbacks!
         @tool_executor.llm_client = @llm_client
         @tool_executor.background_worker = @background_worker
@@ -107,7 +139,10 @@ module RubynCode
           on_tool_call: ->(name, params) { handle_on_tool_call(name, params) },
           on_tool_result: ->(name, result, _is_error = false) { handle_on_tool_result(name, result) },
           on_text: ->(text) { handle_on_text(text) },
-          skill_loader: @skill_loader, project_root: @project_root
+          on_skills_autoloaded: on_skills_autoloaded_callback,
+          skill_loader: @skill_loader, skill_matcher: @skill_matcher,
+          web_skill_autoload: @web_skill_autoload,
+          project_root: @project_root
         )
       end
 
@@ -139,6 +174,8 @@ module RubynCode
         dirs << project_skills if Dir.exist?(project_skills)
         user_skills = File.join(Config::Defaults::HOME_DIR, 'skills')
         dirs << user_skills if Dir.exist?(user_skills)
+        skill_packs = File.join(Config::Defaults::HOME_DIR, 'skill-packs')
+        dirs << skill_packs if Dir.exist?(skill_packs)
         dirs
       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/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/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/protocol.rb

@@ -25,7 +25,8 @@ module RubynCode
 
       # 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/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
 

data/lib/rubyn_code/mcp/tool_bridge.rb

@@ -51,7 +51,7 @@ module RubynCode
           klass
         end
 
-        def create_tool_class(tool_name, description, parameters, mcp_client, remote_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- dynamic class creation requires setting many constants
+        def create_tool_class(tool_name, description, parameters, mcp_client, remote_name) # rubocop:disable Metrics/MethodLength -- dynamic class creation requires setting many constants
           bridge = self
 
           Class.new(Tools::Base) do

data/lib/rubyn_code/observability/usage_reporter.rb

@@ -80,7 +80,8 @@ module RubynCode
         }
       end
 
-      def build_session_summary_lines(session_id, turns, totals) # rubocop:disable Metrics/AbcSize -- assembles multi-field summary
+      # -- assembles multi-field summary
+      def build_session_summary_lines(session_id, turns, totals)
         avg_cost = turns.positive? ? totals[:cost] / turns : 0.0
         [
           header('Session Summary'),
@@ -104,7 +105,8 @@ module RubynCode
         ).to_a
       end
 
-      def build_daily_summary_lines(today, rows) # rubocop:disable Metrics/AbcSize -- assembles multi-field daily summary
+      # -- assembles multi-field daily summary
+      def build_daily_summary_lines(today, rows)
         total_input  = rows.sum { |r| fetch_int(r, 'input_tokens') }
         total_output = rows.sum { |r| fetch_int(r, 'output_tokens') }
         total_cost   = rows.sum { |r| fetch_float(r, 'cost_usd') }