pwn 0.5.756 → 0.5.757

data/lib/pwn/plugins/repl/ai_console.rb

@@ -686,7 +686,7 @@ module PWN
 
             return clear_view if key == "\u000c"
 
-            if key == "\u0007"
+            if ["\u0007", "\u0013"].include?(key)
               @workspace ? @workspace = nil : open_swarm
               return
             end
@@ -709,7 +709,7 @@ module PWN
               return
             end
 
-            if key == "\u0018"
+            if ["\u0018", "\u0014"].include?(key)
               @menu = nil
               @focus = @focus == :session ? :mission : :session
               return
@@ -757,9 +757,18 @@ module PWN
               end
             when :page_up then @scroll = [(@scroll || (@total_rows.to_i - @page_size.to_i)) - @page_size.to_i, 0].max
             when :page_down
-              @scroll = [@scroll.to_i + @page_size.to_i, @total_rows.to_i].min
-              @scroll = nil if @scroll >= [@total_rows.to_i - @page_size.to_i, 0].max
-              @unseen = 0 unless @scroll
+              bottom = [@total_rows.to_i - @page_size.to_i, 0].max
+              # nil is the live end, not row 0. Treating it as 0 jumps upward, then later presses walk back down.
+              if @scroll.nil? || @scroll >= bottom
+                @scroll = nil
+                @unseen = 0
+              else
+                @scroll = [@scroll + @page_size.to_i, bottom].min
+                if @scroll >= bottom
+                  @scroll = nil
+                  @unseen = 0
+                end
+              end
             when "\t" then accept_completion
             when :home, :end
               if @focus == :session
@@ -1247,11 +1256,34 @@ module PWN
             end
           end
 
+          def header_content_limit
+            compose = @compose_height || 5
+            footer = @footer_height || 1
+            [@height.to_i - compose - footer - 6, 1].max
+          end
+
+          def footer_text
+            text = '/ menu · ^C=cancel · ^D=back · ^L=clear · ^T=toggle pane · ^S=swarm · ^R=search ^O=operations · ↑↓ history · Shift+Enter=newline · Enter=send'
+            @focus == :session ? text.sub('↑↓ history', '↑↓ scroll · HOME · PGUP · PGDN · END') : text
+          end
+
+          def footer_lines
+            wrap(footer_text, [@width.to_i - 2, 1].max)
+          end
+
+          def layout_chrome
+            footer = footer_lines
+            compose = 5
+            footer_height = footer.length
+            compose -= 1 while @height.to_i - 4 - compose - footer_height < 3 && compose > 3
+            [footer, compose, footer_height]
+          end
+
           def draw_header(engine, model)
             header_layout(engine, model)
             content = header_lines(engine, model, @header_text_width)
             # Reserve only the physical minimum: timeline (3), composer (6), footer (1).
-            visible = @header_spans.first([@height - 13, 1].max)
+            visible = @header_spans.first([header_content_limit, 1].max)
             overflow = visible.length < content.length ? ' · ^O full settings' : ''
             height = @header_pane_height || (visible.length + 3)
             left = @header_pane_height || 0
@@ -1303,11 +1335,14 @@ module PWN
             end
             engine = PWN::Env.dig(:ai, :active).to_s
             model = REPL.pwn_ai_engine_model(engine: engine)
+            footer, compose_height, footer_height = layout_chrome
+            @compose_height = compose_height
+            @footer_height = footer_height
             header_height = draw_header(engine, model)
             sidebar = @width >= 100 ? 27 : 0
             pane_width = @width - sidebar - 2
-            compose_height = 6
-            timeline_height = @height - compose_height - 1 - header_height
+            timeline_height = @height - compose_height - footer_height - header_height
+            timeline_height = 3 if timeline_height < 3
             @page_size = timeline_height - 2
             rows = timeline_rows(pane_width - 6)
             @total_rows = rows.length
@@ -1320,19 +1355,13 @@ module PWN
             start = @scroll || [rows.length - @page_size, 0].max
             rows.slice(start, @page_size).to_a.each_with_index { |(color, row), index| put(header_height + 1 + index, 2, row, color) }
             draw_sidebar(header_height, pane_width + 1, timeline_height) if sidebar.positive?
-            compose_y = @height - compose_height - 1
+            compose_y = @height - compose_height - footer_height
             mission_title = @focus == :session ? 'MISSION CONTROL' : 'MISSION CONTROL · active'
             box(compose_y, 0, compose_height, @width - 1, mission_title)
             mark_active(compose_y, 0, @width - 1, mission_title) if @focus != :session
-            draw_composer(compose_y)
-            hint = if @menu
-                     '↑↓/^P/^N select · Tab accept · Esc close'
-                   elsif @focus == :session
-                     '↑↓/Home/End scroll · ^X mission'
-                   else
-                     '↑↓ history · ^X session'
-                   end
-            put(@height - 1, 1, "^C cancel ^D back · #{hint} · ^G swarm ^L clear ^R search ^O status · Enter send", tone(:footer))
+            draw_composer(compose_y, height: compose_height)
+            footer_top = @height - footer_height
+            footer.first(footer_height).each_with_index { |line, index| put(footer_top + index, 1, line, tone(:footer)) }
             draw_menu if @menu
             draw_model_prompt if @model_prompt
             draw_details(engine, model) if @details
@@ -1346,30 +1375,29 @@ module PWN
             @screen.refresh
           end
 
-          def draw_composer(top)
-            return draw_search(top) if @editor.search
+          def draw_composer(top, height: 5)
+            return draw_search(top, height: height) if @editor.search
 
             chars = @editor.text.scan(/\X/)
             before = chars.take(@editor.cursor).join
             rows = wrap(@editor.text, @width - 8, words: false)
             prefix = wrap(before, @width - 8, words: false)
             cursor_row = prefix.length - 1
-            first = [cursor_row - 2, 0].max
+            interior = [height - 2, 1].max
+            first = [cursor_row - (interior - 1), 0].max
             put(top + 1, 2, '›', tone(:prompt)) if first.zero?
-            rows.slice(first, 3).to_a.each_with_index { |row, index| put(top + 1 + index, 4, row, tone(:composer)) }
-            hint = @menu ? 'Tab accept · ↑↓/^P/^N select · Esc close' : '^X pane · ^G swarm · Shift+Enter newline · / commands · ^O status'
-            put(top + 4, 4, fit(hint, @width - 7), tone(:footer))
+            rows.slice(first, interior).to_a.each_with_index { |row, index| put(top + 1 + index, 4, row, tone(:composer)) }
             @cursor_position = [top + 1 + cursor_row - first, [4 + width(prefix.last), @width - 3].min]
           end
 
-          def draw_search(top)
+          def draw_search(top, height: 5)
             search = @editor.search
             query = "reverse search: #{search[:query]}"
             query_rows = wrap(query, @width - 8, words: false)
             put(top + 1, 4, query_rows.last, tone(:category))
             match = search[:match] || '(no match)'
-            wrap(match, @width - 8).first(2).each_with_index { |row, index| put(top + 2 + index, 4, row, tone(:composer)) }
-            put(top + 4, 4, '^R older · Enter accept · Esc cancel', tone(:footer))
+            interior = [height - 2, 1].max
+            wrap(match, @width - 8).first([interior - 1, 1].max).each_with_index { |row, index| put(top + 2 + index, 4, row, tone(:composer)) }
             @cursor_position = [top + 1, [4 + width(query_rows.last), @width - 3].min]
           end
 
@@ -1566,9 +1594,9 @@ module PWN
               cursor = [bottom + 2, [3 + width(chars[first...editor.cursor].join), @width - 3].min]
             else
               swarm_put(bottom + 1, "DRAFT: #{@editor.text}", :composer)
-              swarm_put(bottom + 2, 'Esc/^G return to unchanged mission draft', :footer)
+              swarm_put(bottom + 2, 'Esc/^S/^G return to unchanged mission draft', :footer)
             end
-            put(@height - 1, 1, '^D back · ^G close · actions require Enter', tone(:footer))
+            put(@height - 1, 1, '^D back · ^S/^G close · actions require Enter', tone(:footer))
             @screen.setpos(*(cursor || [0, 2]))
           end
 
@@ -1623,7 +1651,7 @@ module PWN
         public_class_method def self.help
           puts "USAGE:
             # Ctrl+L clears only the session pane, including while busy.
-            # Ctrl+X switches the active pane between SESSION and MISSION CONTROL.
+            # Ctrl+T toggles the active pane between SESSION and MISSION CONTROL. Ctrl+S opens swarm.
             # Up/Down select in menus, recall ~/.pwn/pwn_history in the mission pane, and scroll the session pane when it is active.
             # Search: Enter accepts without sending; Esc restores the draft.
             # Launch the single-owner curses console; non-terminals return unavailable.

data/lib/pwn/plugins/repl/ai_console_usage.rb

@@ -3,7 +3,8 @@
 module PWN
   module Plugins
     module REPL
-      # Provider-reported token totals and explicitly configured USD estimates.
+      # Provider-reported token totals. USD comes from the active model's published
+      # prices, then from explicitly configured rates. Missing prices stay unavailable.
       module AIConsoleUsage
         # Accumulate one observer event per provider completion.
         class Tracker
@@ -18,11 +19,15 @@ module PWN
             @priced = 0.0
             @priced_calls = 0
             @unpriced_calls = 0
+            @catalog_priced = 0
+            @configured_priced = 0
           end
 
           def record(opts = {})
             usage = AIConsoleUsage.normalize(opts)
-            price = AIConsoleUsage.estimate(opts.merge(usage: usage))
+            rates = opts[:rates] || AIConsoleUsage.send(:rates_for, engine: opts[:engine], model: opts[:model])
+            price = AIConsoleUsage.estimate(usage: usage, rates: rates)
+            source = rates.is_a?(Hash) ? rates[:source].to_s : ''
             @lock.synchronize do
               @input += usage[:input_tokens]
               @output += usage[:output_tokens]
@@ -33,6 +38,11 @@ module PWN
               if price
                 @priced += price
                 @priced_calls += 1
+                if source == 'provider'
+                  @catalog_priced += 1
+                else
+                  @configured_priced += 1
+                end
               else
                 @unpriced_calls += 1
               end
@@ -44,10 +54,14 @@ module PWN
             @lock.synchronize do
               status = if @calls.zero?
                          'no provider usage yet'
+                       elsif @unpriced_calls.zero? && @catalog_priced.positive? && @configured_priced.zero?
+                         'estimated from provider model pricing'
+                       elsif @unpriced_calls.zero? && @catalog_priced.positive?
+                         'estimated from configured USD rates and provider model pricing'
                        elsif @unpriced_calls.zero?
                          'estimated from configured USD rates'
                        elsif @priced_calls.zero?
-                         'unavailable: no configured USD rate'
+                         'unavailable: no provider or configured USD rate'
                        else
                          "partial: #{@unpriced_calls} call(s) have no configured rate"
                        end
@@ -66,8 +80,8 @@ module PWN
         public_class_method def self.normalize(opts = {})
           raw = opts[:usage].is_a?(Hash) ? opts[:usage] : opts
           details = raw[:input_tokens_details] || raw[:prompt_tokens_details] || {}
-          cached = integer(value: details[:cached_tokens] || details[:cache_read_input_tokens] || raw[:cache_read_input_tokens])
-          written = integer(value: details[:cache_creation_input_tokens] || raw[:cache_creation_input_tokens])
+          cached = integer(value: details[:cached_tokens] || details[:cache_read_input_tokens] || raw[:cache_read_input_tokens] || raw[:cached_tokens])
+          written = integer(value: details[:cache_creation_input_tokens] || raw[:cache_creation_input_tokens] || raw[:cache_write_tokens])
           input = integer(value: raw[:input_tokens] || raw[:prompt_tokens])
           output = integer(value: raw[:output_tokens] || raw[:completion_tokens])
           reasoning = integer(value: (raw[:output_tokens_details] || {})[:reasoning_tokens] || raw[:reasoning_tokens])
@@ -79,10 +93,12 @@ module PWN
 
         # Price only when every used component has an explicit finite USD rate.
         public_class_method def self.estimate(opts = {})
-          usage = opts[:usage] || normalize(opts)
+          raw = opts[:usage].is_a?(Hash) ? opts[:usage] : opts
+          usage = normalize(usage: raw)
           rates = opts[:rates] || rates_for(engine: opts[:engine], model: opts[:model])
           return nil unless rates.is_a?(Hash)
 
+          rates = apply_long_context(rates: rates, usage: usage)
           components = [
             [usage[:input_tokens] - usage[:cached_tokens] - usage[:cache_write_tokens], rates[:input_per_million]],
             [usage[:cached_tokens], rates[:cache_read_per_million] || rates[:input_per_million]],
@@ -106,12 +122,13 @@ module PWN
               usage: 'required - provider usage hash'
             )
 
-            # Estimate USD only from explicit nonnegative rates; nil means unavailable, never zero.
+            # Estimate USD from the active model's published prices, then configured rates.
+            # nil means unavailable, never a fabricated zero.
             #{self}.estimate(
               usage: 'required - normalized or provider usage hash',
               rates: 'optional - input_per_million, output_per_million, cache_read_per_million, cache_write_per_million',
-              engine: 'optional - provider used to read configured rates',
-              model: 'optional - model key under that provider pricing hash'
+              engine: 'optional - provider whose get_model record publishes prices',
+              model: 'optional - model id passed to that provider get_model'
             )
 
             # Return module authors.
@@ -129,15 +146,184 @@ module PWN
         end
 
         private_class_method def self.rates_for(opts = {})
+          catalog = catalog_rates(opts)
+          return catalog.merge(source: 'provider') if catalog
+
+          configured = configured_rates(opts)
+          configured&.merge(source: 'configured')
+        rescue StandardError
+          configured_rates(opts)&.merge(source: 'configured')
+        end
+
+        private_class_method def self.configured_rates(opts = {})
           engine = opts[:engine].to_s.to_sym
           model = opts[:model].to_s
           pricing = PWN::Env.dig(:ai, engine, :pricing) if defined?(PWN::Env)
           return nil unless pricing.is_a?(Hash)
 
-          pricing[model.to_sym] || pricing[model]
+          found = pricing[model.to_sym] || pricing[model]
+          found.is_a?(Hash) ? found : nil
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.catalog_rates(opts = {})
+          rates = extract_rates(row: model_record(opts))
+          return nil unless rates.is_a?(Hash)
+          return nil unless rate?(value: rates[:input_per_million]) && rate?(value: rates[:output_per_million])
+          return nil unless rates[:input_per_million].positive? && rates[:output_per_million].positive?
+
+          rates
+        end
+
+        private_class_method def self.model_record(opts = {})
+          engine = opts[:engine].to_s
+          model = opts[:model].to_s
+          return nil if engine.empty? || model.empty?
+
+          key = "#{engine}\0#{model}"
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          hit = catalog_lock.synchronize { catalog_cache[key] }
+          return hit[:row] if hit && hit[:until] > now
+
+          klass = provider_class(engine: engine)
+          row = klass.get_model(name: model, timeout: 8, fallback: false, non_interactive: true) if klass.respond_to?(:get_model)
+          catalog_lock.synchronize do
+            catalog_cache[key] = { until: now + (row.is_a?(Hash) ? 300 : 30), row: row }
+          end
+          row
         rescue StandardError
           nil
         end
+
+        private_class_method def self.provider_class(opts = {})
+          name = {
+            'anthropic' => :Anthropic, 'gemini' => :Gemini, 'grok' => :Grok,
+            'ollama' => :Ollama, 'openai' => :OpenAI, 'openwebui' => :OpenWebUI
+          }[opts[:engine].to_s.downcase]
+          return nil if name.nil? || !defined?(PWN::AI) || !PWN::AI.const_defined?(name)
+
+          PWN::AI.const_get(name)
+        end
+
+        private_class_method def self.extract_rates(opts = {})
+          row = opts[:row]
+          return nil unless row.is_a?(Hash)
+
+          xai = xai_rates(row: row)
+          return xai if xai
+
+          hashes = pricing_hashes(row: row)
+          input = pick_rate(hashes: hashes, keys: %i[input_per_million input_per_1m input_per_mtok input prompt prompt_price input_cost_per_token input_token_cost])
+          output = pick_rate(hashes: hashes, keys: %i[output_per_million output_per_1m output_per_mtok output completion completion_price output_cost_per_token output_token_cost])
+          return nil unless input && output
+
+          {
+            input_per_million: input,
+            output_per_million: output,
+            cache_read_per_million: pick_rate(hashes: hashes, keys: %i[cache_read_per_million cached_input cached_input_per_million cache_read cached_prompt input_cache_read]),
+            cache_write_per_million: pick_rate(hashes: hashes, keys: %i[cache_write_per_million cache_write cache_creation cache_creation_input_tokens])
+          }.compact
+        end
+
+        # xAI publishes integer USD cents per 100 million tokens. Zero is unpublished, not free.
+        private_class_method def self.xai_rates(opts = {})
+          row = opts[:row]
+          return nil unless row.key?(:prompt_text_token_price) || row.key?('prompt_text_token_price')
+
+          input = xai_usd(value: row[:prompt_text_token_price] || row['prompt_text_token_price'])
+          output = xai_usd(value: row[:completion_text_token_price] || row['completion_text_token_price'])
+          return nil unless input && output
+
+          rates = {
+            input_per_million: input,
+            output_per_million: output,
+            cache_read_per_million: xai_usd(value: row[:cached_prompt_text_token_price] || row['cached_prompt_text_token_price'])
+          }
+          threshold = numeric_value(value: row[:long_context_threshold] || row[:prompt_token_price_threshold])
+          if threshold&.positive?
+            rates[:long_context_tokens] = threshold
+            rates[:long_input_per_million] = xai_usd(value: row[:prompt_text_token_price_long_context])
+            rates[:long_output_per_million] = xai_usd(value: row[:completion_text_token_price_long_context])
+            rates[:long_cache_read_per_million] = xai_usd(value: row[:cached_prompt_text_token_price_long_context])
+          end
+          rates.compact
+        end
+
+        private_class_method def self.xai_usd(opts = {})
+          number = numeric_value(value: opts[:value])
+          return nil unless number&.finite? && number.positive?
+
+          number / 10_000.0
+        end
+
+        private_class_method def self.apply_long_context(opts = {})
+          rates = opts[:rates]
+          threshold = rates[:long_context_tokens]
+          return rates unless threshold.is_a?(Numeric) && threshold.positive?
+          return rates if opts[:usage][:input_tokens].to_i < threshold
+
+          swapped = rates.dup
+          swapped[:input_per_million] = rates[:long_input_per_million] if rate?(value: rates[:long_input_per_million])
+          swapped[:output_per_million] = rates[:long_output_per_million] if rate?(value: rates[:long_output_per_million])
+          swapped[:cache_read_per_million] = rates[:long_cache_read_per_million] if rate?(value: rates[:long_cache_read_per_million])
+          swapped
+        end
+
+        private_class_method def self.pricing_hashes(opts = {})
+          row = opts[:row]
+          nested = [
+            row, row[:pricing], row['pricing'], row[:price], row[:costs],
+            row.dig(:info, :pricing), row.dig(:info, :meta, :pricing), row.dig(:info, 'meta', 'pricing'),
+            row.dig(:metadata, :pricing), row.dig(:details, :pricing)
+          ]
+          nested.grep(Hash)
+        end
+
+        private_class_method def self.pick_rate(opts = {})
+          opts[:hashes].each do |hash|
+            opts[:keys].each do |key|
+              value = hash[key] || hash[key.to_s]
+              rate = money_per_million(value: value, key: key)
+              return rate if rate
+            end
+          end
+          nil
+        end
+
+        private_class_method def self.money_per_million(opts = {})
+          value = opts[:value]
+          if value.is_a?(Hash)
+            unit = (value[:unit] || value['unit'] || value[:per] || value['per']).to_s
+            value = value[:usd] || value['usd'] || value[:amount] || value['amount'] || value[:price] || value['price']
+            opts = opts.merge(value: value, key: unit.empty? ? opts[:key] : unit)
+          end
+          number = numeric_value(value: opts[:value])
+          return nil unless number&.finite? && number.positive?
+
+          key = opts[:key].to_s
+          per_million = key.match?(/per_million|per_1m|per_mtok/)
+          per_token = key.match?(/per_token|token_cost|cost_per_token/) || (!per_million && number < 0.001)
+          per_token ? number * 1_000_000 : number
+        end
+
+        private_class_method def self.numeric_value(opts = {})
+          value = opts[:value]
+          return value if value.is_a?(Numeric)
+          return nil unless value.is_a?(String) && value.match?(/\A-?\d+(\.\d+)?\z/)
+
+          Float(value)
+        rescue StandardError
+          nil
+        end
+
+        private_class_method def self.catalog_lock
+          @catalog_lock ||= Mutex.new
+        end
+
+        private_class_method def self.catalog_cache
+          @catalog_cache ||= {}
+        end
       end
     end
   end

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.756'
+  VERSION = '0.5.757'
 end

data/spec/lib/pwn/ai/grok_spec.rb

@@ -13,6 +13,14 @@ describe PWN::AI::Grok do
     expect(help_response).to respond_to :help
   end
 
+  it 'loads one priced model without listing the catalog' do
+    allow(described_class).to receive(:grok_rest_call).and_return('{"id":"grok-4.7","prompt_text_token_price":20000,"completion_text_token_price":60000}')
+    row = described_class.get_model(name: 'grok-4.7')
+    expect(row[:id]).to eq('grok-4.7')
+    expect(described_class).to have_received(:grok_rest_call).once
+    expect { described_class.get_model(name: ' ') }.to raise_error(RuntimeError, /Model name is required/)
+  end
+
   it 'chat_with_tools sanitizes messages via Loop.openai_wire_messages' do
     src = File.read(described_class.method(:chat_with_tools).source_location.first)
     expect(src).to match(/openai_wire_messages/)

data/spec/lib/pwn/ai/model_catalog_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::AI::ModelCatalog do
+  it 'finds a named row across provider catalog shapes' do
+    grok = described_class.find_row(models: [{ id: 'grok-4.7', aliases: ['grok-latest'] }], name: 'grok-latest')
+    expect(grok[:id]).to eq('grok-4.7')
+
+    openai = described_class.find_row(models: { models: [{ slug: 'gpt-5.5' }] }, name: 'gpt-5.5')
+    expect(openai[:slug]).to eq('gpt-5.5')
+
+    gemini = described_class.find_row(models: [{ name: 'models/gemini-2.5-pro' }], name: 'gemini-2.5-pro')
+    expect(gemini[:name]).to eq('models/gemini-2.5-pro')
+
+    ollama = described_class.find_row(models: { models: [{ name: 'llama3.2', model: 'llama3.2:latest' }] }, name: 'llama3.2')
+    expect(ollama[:model]).to eq('llama3.2:latest')
+  end
+
+  it 'rejects error strings and keeps a short non-interactive lookup' do
+    expect(described_class.parse_row(raw: 'ERROR: timed out')).to be_nil
+    expect(described_class.model_row?(row: { error: 'missing' })).to be false
+    expect(described_class.lookup_opts(timeout: 8)[:non_interactive]).to be true
+    expect(described_class.lookup_opts(timeout: 8)[:timeout]).to eq(8)
+  end
+end

data/spec/lib/pwn/ai/model_lookup_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'provider get_model routes' do
+  it 'asks each engine for one model on that engine route' do
+    allow(PWN::AI::Anthropic).to receive(:anthropic_rest_call).and_return('{"id":"claude-mythos-5","type":"model"}')
+    expect(PWN::AI::Anthropic.get_model(name: 'claude-mythos-5')[:id]).to eq('claude-mythos-5')
+    expect(PWN::AI::Anthropic).to have_received(:anthropic_rest_call).with(hash_including(rest_call: 'models/claude-mythos-5'))
+
+    allow(PWN::AI::Gemini).to receive(:gemini_rest_call).and_return('{"name":"models/gemini-2.5-pro"}')
+    expect(PWN::AI::Gemini.get_model(name: 'models/gemini-2.5-pro')[:name]).to eq('models/gemini-2.5-pro')
+    expect(PWN::AI::Gemini).to have_received(:gemini_rest_call).with(hash_including(rest_call: 'models/gemini-2.5-pro'))
+
+    allow(PWN::AI::Ollama).to receive(:ollama_rest_call).and_return('{"name":"llama3.2","model":"llama3.2"}')
+    expect(PWN::AI::Ollama.get_model(name: 'llama3.2')[:model]).to eq('llama3.2')
+    expect(PWN::AI::Ollama).to have_received(:ollama_rest_call).with(hash_including(http_method: :post, rest_call: 'api/show'))
+
+    allow(PWN::AI::OpenAI).to receive(:open_ai_rest_call).and_return('{"slug":"gpt-5.5"}')
+    expect(PWN::AI::OpenAI.get_model(name: 'gpt-5.5')[:slug]).to eq('gpt-5.5')
+    expect(PWN::AI::OpenAI).to have_received(:open_ai_rest_call).with(hash_including(rest_call: 'models/gpt-5.5'))
+
+    allow(PWN::AI::OpenWebUI).to receive(:openwebui_rest_call).and_return('{"id":"proxy-model"}')
+    expect(PWN::AI::OpenWebUI.get_model(name: 'proxy-model')[:id]).to eq('proxy-model')
+    expect(PWN::AI::OpenWebUI).to have_received(:openwebui_rest_call).with(hash_including(rest_call: 'api/v1/models/proxy-model'))
+  end
+end

data/spec/lib/pwn/plugins/repl/ai_console_spec.rb

@@ -967,7 +967,18 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     expect(console.instance_variable_get(:@scroll)).to eq(0)
     console.handle(:end)
     expect(console.instance_variable_get(:@scroll)).to be_nil
+    console.handle(:page_up)
+    expect(console.instance_variable_get(:@scroll)).to eq(60)
+    console.handle(:page_down)
+    expect(console.instance_variable_get(:@scroll)).to be_nil
+    console.handle(:page_down)
+    expect(console.instance_variable_get(:@scroll)).to be_nil
+    console.handle(:home)
+    expect(console.instance_variable_get(:@scroll)).to eq(0)
+    console.handle(:page_up)
+    expect(console.instance_variable_get(:@scroll)).to eq(0)
     expect(console.instance_variable_get(:@unseen)).to eq(0)
+    console.handle(:end)
     console.handle(:up)
     console.handle(:down)
     expect(console.instance_variable_get(:@scroll)).to be_nil
@@ -1003,6 +1014,38 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     expect(screen).to have_received(:setpos).with(a_kind_of(Integer), 2)
   end
 
+  it 'toggles the pane with Ctrl+T and opens swarm with Ctrl+S' do
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
+    console.handle("\u0014")
+    expect(console.instance_variable_get(:@focus)).to eq(:session)
+    console.handle("\u0013")
+    expect(console.instance_variable_get(:@workspace)).to be_a(Hash)
+    console.handle("\u0013")
+    expect(console.instance_variable_get(:@workspace)).to be_nil
+  end
+
+  it 'wraps the footer inside the window and omits the composer hint line' do
+    screen = double(erase: nil, refresh: nil, setpos: nil, addstr: nil)
+    curses = double(lines: 24, cols: 48)
+    console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: curses, getch: nil)
+    console.instance_variable_set(:@screen, screen)
+    painted = []
+    allow(console).to receive(:put) { |*args| painted << args }
+    console.draw
+    text = painted.map { |row| row[2].to_s }.join("\n")
+    expect(text).not_to include('^X pane')
+    expect(text).to include('^T=toggle pane', '^S=swarm', 'Shift+Enter=newline', 'Enter=send')
+    footer = painted.select { |row| row[2].to_s.include?('^T=toggle pane') || row[2].to_s.include?('Enter=send') || row[2].to_s.include?('/ menu') }
+    expect(footer.length).to be > 1
+    expect(footer).to all(satisfy { |_y, _x, line, _color| console.width(line) <= 46 })
+    console.handle("\u0014")
+    painted.clear
+    console.draw
+    session = painted.map { |row| row[2].to_s }.join
+    expect(session).to include('↑↓ scroll · HOME · PGUP · PGDN · END')
+    expect(session).not_to include('↑↓ history')
+  end
+
   it 'wraps at words without discarding code whitespace or splitting graphemes' do
     console = PWN::Plugins::REPL::AIConsole::Console.new(pry: Pry.new, input: StringIO.new, curses: nil, getch: nil)
     expect(console.wrap('some evidence', 12)).to eq(['some ', 'evidence'])
@@ -1103,8 +1146,9 @@ describe 'pwn-ai curses launch' do # rubocop:disable Metrics/BlockLength -- publ
     resized = false
     launch([]) do
       if resized
-        expect(@paint.last).to include('^C cancel', '^D back')
-        expect(Unicode::DisplayWidth.of(@paint.last)).to be <= 46
+        footer = @paint.select { |line| (line.include?('^C=cancel') || line.include?('Enter=send')) && Unicode::DisplayWidth.of(line) <= 46 }
+        expect(footer.join).to include('^C=cancel', '^D=back')
+        expect(footer.length).to be > 1
         "\u0004"
       else
         allow(@screen).to receive_messages(lines: 14, cols: 48)