pwn 0.5.755 → 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.755'
+  VERSION = '0.5.757'
 end

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

@@ -106,4 +106,31 @@ describe PWN::AI::Anthropic do
     expect(flat[:properties].keys.map(&:to_s)).to include('handle', 'path')
     expect(flat[:description]).to include('handle', 'path')
   end
+
+  it 'does not force tool use on Anthropic models that reject tool_choice any and tool' do
+    allow(PWN::Env).to receive(:[]).with(:ai).and_return(
+      anthropic: { key: 'test-key', model: 'claude-mythos-5', temp: 1, max_tokens: 100 }
+    )
+    allow(PWN::AI::Agent::PromptCache).to receive(:enabled?).and_return(false) if defined?(PWN::AI::Agent::PromptCache)
+    captured = nil
+    allow(described_class).to receive(:anthropic_rest_call) do |opts|
+      captured = opts[:http_body]
+      '{"id":"msg_choice","type":"message","role":"assistant","content":[{"type":"text","text":"ok"}],"stop_reason":"end_turn"}'
+    end
+    tools = [{ type: 'function', function: { name: 'memory_recall', description: 'recall', parameters: { type: 'object', properties: {} } } }]
+    messages = [{ role: 'user', content: 'hello' }]
+
+    described_class.chat_with_tools(messages: messages, tools: tools, model: 'claude-mythos-5', tool_choice: 'required')
+    expect(captured[:tool_choice]).to eq(type: 'any')
+
+    %w[claude-mythos-5-1 claude-fable-5-1 claude-opus-5-5 claude-sonnet-5-5].each do |model|
+      described_class.chat_with_tools(messages: messages, tools: tools, model: model, tool_choice: 'required')
+      expect(captured[:tool_choice]).to eq(type: 'auto'), model
+      described_class.chat_with_tools(messages: messages, tools: tools, model: model, tool_choice: { type: 'function', function: { name: 'memory_recall' } })
+      expect(captured[:tool_choice]).to eq(type: 'auto'), model
+    end
+
+    described_class.chat_with_tools(messages: messages, tools: tools, model: 'claude-mythos-5-1', tool_choice: 'none')
+    expect(captured[:tool_choice]).to eq(type: 'none')
+  end
 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/binary_parser_spec.rb

@@ -91,13 +91,22 @@ describe PWN::Plugins::BinaryParser do
   end
 
   it 'elf_resolve points system at the .plt.sec stub, not the next slot' do
+    x86_64 = RbConfig::CONFIG['host_cpu'].to_s.match?(/amd64|x86_64/)
     Dir.mktmpdir('pwn-elf-ibt-') do |dir|
       src = File.join(dir, 't.c')
       path = File.join(dir, 't')
       File.write(src, "#include <stdlib.h>\nint main(void) { return system(\"x\"); }\n")
-      out, status = Open3.capture2e('cc', '-O0', '-fno-pie', '-no-pie', '-Wl,-z,ibt', '-o', path, src)
+      flags = ['-O0', '-fno-pie', '-no-pie']
+      flags << '-Wl,-z,ibt' if x86_64
+      out, status = Open3.capture2e('cc', *flags, '-o', path, src)
       expect(status.success?).to eq(true), out
-      expect(File.binread(path)).to include('.plt.sec')
+      binary = File.binread(path)
+      unless x86_64
+        expect(binary).not_to include('.plt.sec')
+        next
+      end
+
+      expect(binary).to include('.plt.sec')
       row = described_class.elf_resolve(path: path)
       dump, dump_status = Open3.capture2('objdump', '-d', path)
       expect(dump_status.success?).to eq(true), dump